Start on new patch infrastructure

58 files changed, 4481 insertions, 1192 deletions

diff --git a/src/WixToolset.Core.Burn/Bind/BindBundleCommand.cs b/src/WixToolset.Core.Burn/Bind/BindBundleCommand.cs
index c2164744..283cd115 100644
--- a/src/WixToolset.Core.Burn/Bind/BindBundleCommand.cs
+++ b/src/WixToolset.Core.Burn/Bind/BindBundleCommand.cs
@@ -208,7 +208,6 @@ namespace WixToolset.Core.Burn
                             variableCache.Add(String.Concat("packageManufacturer.", facade.PackageId), msiPackage.Manufacturer);
                         }
                     }
-
                 }
                 break;
 
diff --git a/src/WixToolset.Core.Burn/Bundles/CreateNonUXContainers.cs b/src/WixToolset.Core.Burn/Bundles/CreateNonUXContainers.cs
index 612e0e11..34e601a7 100644
--- a/src/WixToolset.Core.Burn/Bundles/CreateNonUXContainers.cs
+++ b/src/WixToolset.Core.Burn/Bundles/CreateNonUXContainers.cs
@@ -113,7 +113,7 @@ namespace WixToolset.Core.Burn.Bundles
                         ++attachedContainerIndex;
                     }
 
-                    this.CreateContainer(container, containerPayloads, null);
+                    this.CreateContainer(container, containerPayloads);
                 }
             }
 
@@ -122,7 +122,7 @@ namespace WixToolset.Core.Burn.Bundles
             this.FileTransfers = fileTransfers;
         }
 
-        private void CreateContainer(WixBundleContainerTuple container, IEnumerable<WixBundlePayloadTuple> containerPayloads, string manifestFile)
+        private void CreateContainer(WixBundleContainerTuple container, IEnumerable<WixBundlePayloadTuple> containerPayloads)
         {
             var command = new CreateContainerCommand(containerPayloads, container.WorkingPath, this.DefaultCompressionLevel);
             command.Execute();
diff --git a/src/WixToolset.Core.WindowsInstaller/Bind/AssignMediaCommand.cs b/src/WixToolset.Core.WindowsInstaller/Bind/AssignMediaCommand.cs
index 2199bbde..2bfd587f 100644
--- a/src/WixToolset.Core.WindowsInstaller/Bind/AssignMediaCommand.cs
+++ b/src/WixToolset.Core.WindowsInstaller/Bind/AssignMediaCommand.cs
@@ -57,7 +57,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
 
             var mediaRows = new Dictionary<int, MediaTuple>();
 
-            List<FileFacade> uncompressedFiles = new List<FileFacade>();
+            var uncompressedFiles = new List<FileFacade>();
 
             var mediaTable = this.Section.Tuples.OfType<MediaTuple>().ToList();
             var mediaTemplateTable = this.Section.Tuples.OfType<WixMediaTemplateTuple>().ToList();
@@ -109,8 +109,8 @@ namespace WixToolset.Core.WindowsInstaller.Bind
 
             ulong currentPreCabSize = 0;
             ulong maxPreCabSizeInBytes;
-            int maxPreCabSizeInMB = 0;
-            int currentCabIndex = 0;
+            var maxPreCabSizeInMB = 0;
+            var currentCabIndex = 0;
 
             MediaTuple currentMediaRow = null;
 
@@ -131,7 +131,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                 this.CabinetNameTemplate = mediaTemplateRow.CabinetTemplate;
             }
 
-            string mumsString = Environment.GetEnvironmentVariable("WIX_MUMS");
+            var mumsString = Environment.GetEnvironmentVariable("WIX_MUMS");
 
             try
             {
@@ -170,13 +170,13 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                 {
                     // Associate current file with last cab (irrespective of the size) and cab index is not incremented anymore.
                     var cabinetFiles = filesByCabinetMedia[currentMediaRow];
-                    facade.File.DiskId = currentCabIndex;
+                    facade.DiskId = currentCabIndex;
                     cabinetFiles.Add(facade);
                     continue;
                 }
 
                 // Update current cab size.
-                currentPreCabSize += (ulong)facade.File.FileSize;
+                currentPreCabSize += (ulong)facade.FileSize;
 
                 if (currentPreCabSize > maxPreCabSizeInBytes)
                 {
@@ -186,10 +186,10 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                     filesByCabinetMedia.Add(currentMediaRow, new List<FileFacade>());
 
                     var cabinetFileRows = filesByCabinetMedia[currentMediaRow];
-                    facade.File.DiskId = currentCabIndex;
+                    facade.DiskId = currentCabIndex;
                     cabinetFileRows.Add(facade);
                     // Now files larger than MaxUncompressedMediaSize will be the only file in its cabinet so as to respect MaxUncompressedMediaSize
-                    currentPreCabSize = (ulong)facade.File.FileSize;
+                    currentPreCabSize = (ulong)facade.FileSize;
                 }
                 else
                 {
@@ -204,7 +204,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
 
                     // Associate current file with current cab.
                     var cabinetFiles = filesByCabinetMedia[currentMediaRow];
-                    facade.File.DiskId = currentCabIndex;
+                    facade.DiskId = currentCabIndex;
                     cabinetFiles.Add(facade);
                 }
             }
@@ -260,18 +260,18 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                 }
             }
 
-            foreach (FileFacade facade in fileFacades)
+            foreach (var facade in fileFacades)
             {
                 if (!mediaRows.TryGetValue(facade.DiskId, out var mediaRow))
                 {
-                    this.Messaging.Write(ErrorMessages.MissingMedia(facade.File.SourceLineNumbers, facade.DiskId));
+                    this.Messaging.Write(ErrorMessages.MissingMedia(facade.SourceLineNumber, facade.DiskId));
                     continue;
                 }
 
                 // When building a product, if the current file is to be uncompressed or if
                 // the package set not to be compressed, don't cab it.
-                var compressed = (facade.File.Attributes & FileTupleAttributes.Compressed) == FileTupleAttributes.Compressed;
-                var uncompressed = (facade.File.Attributes & FileTupleAttributes.Uncompressed) == FileTupleAttributes.Uncompressed;
+                var compressed = facade.Compressed;
+                var uncompressed = facade.Uncompressed;
                 if (SectionType.Product == this.Section.Type && (uncompressed || (!compressed && !this.FilesCompressed)))
                 {
                     uncompressedFiles.Add(facade);
@@ -284,7 +284,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                     }
                     else
                     {
-                        this.Messaging.Write(ErrorMessages.ExpectedMediaCabinet(facade.File.SourceLineNumbers, facade.File.Id.Id, facade.DiskId));
+                        this.Messaging.Write(ErrorMessages.ExpectedMediaCabinet(facade.SourceLineNumber, facade.Id, facade.DiskId));
                     }
                 }
             }
diff --git a/src/WixToolset.Core.WindowsInstaller/Bind/AttachPatchTransformsCommand.cs b/src/WixToolset.Core.WindowsInstaller/Bind/AttachPatchTransformsCommand.cs
new file mode 100644
index 00000000..aa5ca20a
--- /dev/null
+++ b/src/WixToolset.Core.WindowsInstaller/Bind/AttachPatchTransformsCommand.cs
@@ -0,0 +1,1322 @@
+// 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.Collections.Generic;
+    using System.Globalization;
+    using System.Linq;
+    using System.Text.RegularExpressions;
+    using WixToolset.Core.WindowsInstaller;
+    using WixToolset.Core.WindowsInstaller.Msi;
+    using WixToolset.Data;
+    using WixToolset.Data.Tuples;
+    using WixToolset.Data.WindowsInstaller;
+    using WixToolset.Data.WindowsInstaller.Rows;
+    using WixToolset.Extensibility.Services;
+
+    /// <summary>
+    /// Include transforms in a patch.
+    /// </summary>
+    internal class AttachPatchTransformsCommand
+    {
+        private static readonly string[] PatchUninstallBreakingTables = new[]
+        {
+            "AppId",
+            "BindImage",
+            "Class",
+            "Complus",
+            "CreateFolder",
+            "DuplicateFile",
+            "Environment",
+            "Extension",
+            "Font",
+            "IniFile",
+            "IsolatedComponent",
+            "LockPermissions",
+            "MIME",
+            "MoveFile",
+            "MsiLockPermissionsEx",
+            "MsiServiceConfig",
+            "MsiServiceConfigFailureActions",
+            "ODBCAttribute",
+            "ODBCDataSource",
+            "ODBCDriver",
+            "ODBCSourceAttribute",
+            "ODBCTranslator",
+            "ProgId",
+            "PublishComponent",
+            "RemoveIniFile",
+            "SelfReg",
+            "ServiceControl",
+            "ServiceInstall",
+            "TypeLib",
+            "Verb",
+        };
+
+        private readonly TableDefinitionCollection tableDefinitions;
+
+        public AttachPatchTransformsCommand(IMessaging messaging, Intermediate intermediate, IEnumerable<PatchTransform> transforms)
+        {
+            this.tableDefinitions = new TableDefinitionCollection(WindowsInstallerStandardInternal.GetTableDefinitions());
+            this.Messaging = messaging;
+            this.Intermediate = intermediate;
+            this.Transforms = transforms;
+        }
+
+        private IMessaging Messaging { get; }
+
+        private Intermediate Intermediate { get; }
+
+        private IEnumerable<PatchTransform> Transforms { get; }
+
+        public IEnumerable<SubStorage> SubStorages { get; private set; }
+
+        public IEnumerable<SubStorage> Execute()
+        {
+            var subStorages = new List<SubStorage>();
+
+            if (this.Transforms == null || !this.Transforms.Any())
+            {
+                this.Messaging.Write(ErrorMessages.PatchWithoutTransforms());
+                return subStorages;
+            }
+
+            var summaryInfo = this.ExtractPatchSummaryInfo();
+
+            var section = this.Intermediate.Sections.First();
+
+            var tuples = this.Intermediate.Sections.SelectMany(s => s.Tuples).ToList();
+
+            // Get the patch id from the WixPatchId tuple.
+            var patchIdTuple = tuples.OfType<WixPatchIdTuple>().FirstOrDefault();
+
+            if (String.IsNullOrEmpty(patchIdTuple.Id?.Id))
+            {
+                this.Messaging.Write(ErrorMessages.ExpectedPatchIdInWixMsp());
+                return subStorages;
+            }
+
+            if (String.IsNullOrEmpty(patchIdTuple.ClientPatchId))
+            {
+                this.Messaging.Write(ErrorMessages.ExpectedClientPatchIdInWixMsp());
+                return subStorages;
+            }
+
+            // enumerate patch.Media to map diskId to Media row
+            var patchMediaByDiskId = tuples.OfType<MediaTuple>().ToDictionary(t => t.DiskId);
+
+            if (patchMediaByDiskId.Count == 0)
+            {
+                this.Messaging.Write(ErrorMessages.ExpectedMediaRowsInWixMsp());
+                return subStorages;
+            }
+
+            // populate MSP summary information
+            var patchMetadata = this.PopulateSummaryInformation(summaryInfo, tuples, patchIdTuple, section.Codepage);
+
+            // enumerate transforms
+            var productCodes = new SortedSet<string>();
+            var transformNames = new List<string>();
+            var validTransform = new List<Tuple<string, WindowsInstallerData>>();
+
+            var baselineTuplesById = tuples.OfType<WixPatchBaselineTuple>().ToDictionary(t => t.Id.Id);
+
+            foreach (var mainTransform in this.Transforms)
+            {
+                var baselineTuple = baselineTuplesById[mainTransform.Baseline];
+
+                var patchRefTuples = tuples.OfType<WixPatchRefTuple>().ToList();
+                if (patchRefTuples.Count > 0)
+                {
+                    if (!this.ReduceTransform(mainTransform.Transform, patchRefTuples))
+                    {
+                        // transform has none of the content authored into this patch
+                        continue;
+                    }
+                }
+
+                // Validate the transform doesn't break any patch specific rules.
+                this.Validate(mainTransform);
+
+                // ensure consistent File.Sequence within each Media
+                var mediaTuple = patchMediaByDiskId[baselineTuple.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)
+                {
+                    foreach (MediaRow transformMediaRow in transformMediaTable.Rows)
+                    {
+                        if (mediaTuple.LastSequence < transformMediaRow.LastSequence)
+                        {
+                            // The Binder will pre-increment the sequence.
+                            mediaTuple.LastSequence = transformMediaRow.LastSequence;
+                        }
+                    }
+                }
+
+                // Use the Media/@DiskId if greater than the last sequence for backward compatibility.
+                if (mediaTuple.LastSequence < mediaTuple.DiskId)
+                {
+                    mediaTuple.LastSequence = mediaTuple.DiskId;
+                }
+
+                // Ignore media table in the transform.
+                mainTransform.Transform.Tables.Remove("Media");
+                mainTransform.Transform.Tables.Remove("WixMedia");
+                mainTransform.Transform.Tables.Remove("MsiDigitalSignature");
+
+                var pairedTransform = this.BuildPairedTransform(summaryInfo, patchMetadata, patchIdTuple, mainTransform.Transform, mediaTuple, baselineTuple, out var productCode);
+
+                productCode = productCode.ToUpperInvariant();
+                productCodes.Add(productCode);
+                validTransform.Add(Tuple.Create(productCode, mainTransform.Transform));
+
+                // attach these transforms to the patch object
+                // TODO: is this an acceptable way to auto-generate transform stream names?
+                var transformName = mainTransform.Baseline + "." + validTransform.Count.ToString(CultureInfo.InvariantCulture);
+                subStorages.Add(new SubStorage(transformName, mainTransform.Transform));
+                subStorages.Add(new SubStorage("#" + transformName, pairedTransform));
+
+                transformNames.Add(":" + transformName);
+                transformNames.Add(":#" + transformName);
+            }
+
+            if (validTransform.Count == 0)
+            {
+                this.Messaging.Write(ErrorMessages.PatchWithoutValidTransforms());
+                return subStorages;
+            }
+
+            // Validate that a patch authored as removable is actually removable
+            if (patchMetadata.TryGetValue("AllowRemoval", out var allowRemoval) && allowRemoval.Value == "1")
+            {
+                var uninstallable = true;
+
+                foreach (var entry in validTransform)
+                {
+                    uninstallable &= this.CheckUninstallableTransform(entry.Item1, entry.Item2);
+                }
+
+                if (!uninstallable)
+                {
+                    this.Messaging.Write(ErrorMessages.PatchNotRemovable());
+                    return subStorages;
+                }
+            }
+
+            // Finish filling tables with transform-dependent data.
+            productCodes = FinalizePatchProductCodes(tuples, productCodes);
+
+            // Semicolon delimited list of the product codes that can accept the patch.
+            summaryInfo.Add(SumaryInformationType.PatchProductCodes, new SummaryInformationTuple(patchIdTuple.SourceLineNumbers)
+            {
+                PropertyId = SumaryInformationType.PatchProductCodes,
+                Value = String.Join(";", productCodes)
+            });
+
+            // Semicolon delimited list of transform substorage names in the order they are applied.
+            summaryInfo.Add(SumaryInformationType.TransformNames, new SummaryInformationTuple(patchIdTuple.SourceLineNumbers)
+            {
+                PropertyId = SumaryInformationType.TransformNames,
+                Value = String.Join(";", transformNames)
+            });
+
+            // Put the summary information that was extracted back in now that it is updated.
+            foreach (var readSummaryInfo in summaryInfo.Values.OrderBy(s => s.PropertyId))
+            {
+                section.Tuples.Add(readSummaryInfo);
+            }
+
+            this.SubStorages = subStorages;
+
+            return subStorages;
+        }
+
+        private Dictionary<SumaryInformationType, SummaryInformationTuple> ExtractPatchSummaryInfo()
+        {
+            var result = new Dictionary<SumaryInformationType, SummaryInformationTuple>();
+
+            foreach (var section in this.Intermediate.Sections)
+            {
+                for (var i = section.Tuples.Count - 1; i >= 0; i--)
+                {
+                    if (section.Tuples[i] is SummaryInformationTuple patchSummaryInfo)
+                    {
+                        // Remove all summary information from the tuples and remember those that
+                        // are not calculated or reserved.
+                        section.Tuples.RemoveAt(i);
+
+                        if (patchSummaryInfo.PropertyId != SumaryInformationType.PatchProductCodes &&
+                            patchSummaryInfo.PropertyId != SumaryInformationType.PatchCode &&
+                            patchSummaryInfo.PropertyId != SumaryInformationType.PatchInstallerRequirement &&
+                            patchSummaryInfo.PropertyId != SumaryInformationType.Reserved11 &&
+                            patchSummaryInfo.PropertyId != SumaryInformationType.Reserved14 &&
+                            patchSummaryInfo.PropertyId != SumaryInformationType.Reserved16)
+                        {
+                            result.Add(patchSummaryInfo.PropertyId, patchSummaryInfo);
+                        }
+                    }
+                }
+            }
+
+            return result;
+        }
+
+        private Dictionary<string, MsiPatchMetadataTuple> PopulateSummaryInformation(Dictionary<SumaryInformationType, SummaryInformationTuple> summaryInfo, List<IntermediateTuple> tuples, WixPatchIdTuple patchIdTuple, int codepage)
+        {
+            // PID_CODEPAGE
+            if (!summaryInfo.ContainsKey(SumaryInformationType.Codepage))
+            {
+                // Set the code page by default to the same code page for the
+                // string pool in the database.
+                AddSummaryInformation(SumaryInformationType.Codepage, codepage.ToString(CultureInfo.InvariantCulture), patchIdTuple.SourceLineNumbers);
+            }
+
+            // GUID patch code for the patch.
+            AddSummaryInformation(SumaryInformationType.PatchCode, patchIdTuple.Id.Id, patchIdTuple.SourceLineNumbers);
+
+            // Indicates the minimum Windows Installer version that is required to install the patch.
+            AddSummaryInformation(SumaryInformationType.PatchInstallerRequirement, ((int)SummaryInformation.InstallerRequirement.Version31).ToString(CultureInfo.InvariantCulture), patchIdTuple.SourceLineNumbers);
+
+            if (!summaryInfo.ContainsKey(SumaryInformationType.Security))
+            {
+                AddSummaryInformation(SumaryInformationType.Security, "4", patchIdTuple.SourceLineNumbers); // Read-only enforced;
+            }
+
+            // Use authored comments or default to display name.
+            MsiPatchMetadataTuple commentsTuple = null;
+
+            var metadataTuples = tuples.OfType<MsiPatchMetadataTuple>().Where(t => String.IsNullOrEmpty(t.Company)).ToDictionary(t => t.Property);
+
+            if (!summaryInfo.ContainsKey(SumaryInformationType.Title) &&
+                metadataTuples.TryGetValue("DisplayName", out var displayName))
+            {
+                AddSummaryInformation(SumaryInformationType.Title, displayName.Value, displayName.SourceLineNumbers);
+
+                // Default comments to use display name as-is.
+                commentsTuple = displayName;
+            }
+
+            // TODO: This code below seems unnecessary given the codepage is set at the top of this method.
+            //if (!summaryInfo.ContainsKey(SumaryInformationType.Codepage) &&
+            //    metadataValues.TryGetValue("CodePage", out var codepage))
+            //{
+            //    AddSummaryInformation(SumaryInformationType.Codepage, codepage);
+            //}
+
+            if (!summaryInfo.ContainsKey(SumaryInformationType.PatchPackageName) &&
+                metadataTuples.TryGetValue("Description", out var description))
+            {
+                AddSummaryInformation(SumaryInformationType.PatchPackageName, description.Value, description.SourceLineNumbers);
+            }
+
+            if (!summaryInfo.ContainsKey(SumaryInformationType.Author) &&
+                metadataTuples.TryGetValue("ManufacturerName", out var manufacturer))
+            {
+                AddSummaryInformation(SumaryInformationType.Author, manufacturer.Value, manufacturer.SourceLineNumbers);
+            }
+
+            // Special metadata marshalled through the build.
+            //var wixMetadataValues = tuples.OfType<WixPatchMetadataTuple>().ToDictionary(t => t.Id.Id, t => t.Value);
+
+            //if (wixMetadataValues.TryGetValue("Comments", out var wixComments))
+            if (metadataTuples.TryGetValue("Comments", out var wixComments))
+            {
+                commentsTuple = wixComments;
+            }
+
+            // Write the package comments to summary info.
+            if (!summaryInfo.ContainsKey(SumaryInformationType.Comments) &&
+                commentsTuple != null)
+            {
+                AddSummaryInformation(SumaryInformationType.Comments, commentsTuple.Value, commentsTuple.SourceLineNumbers);
+            }
+
+            return metadataTuples;
+
+            void AddSummaryInformation(SumaryInformationType type, string value, SourceLineNumber sourceLineNumber)
+            {
+                summaryInfo.Add(type, new SummaryInformationTuple(sourceLineNumber)
+                {
+                    PropertyId = type,
+                    Value = value
+                });
+            }
+        }
+
+        /// <summary>
+        /// Ensure transform is uninstallable.
+        /// </summary>
+        /// <param name="productCode">Product code in transform.</param>
+        /// <param name="transform">Transform generated by torch.</param>
+        /// <returns>True if the transform is uninstallable</returns>
+        private bool CheckUninstallableTransform(string productCode, WindowsInstallerData transform)
+        {
+            var success = true;
+
+            foreach (var tableName in PatchUninstallBreakingTables)
+            {
+                if (transform.TryGetTable(tableName, out var table))
+                {
+                    foreach (var row in table.Rows)
+                    {
+                        if (row.Operation == RowOperation.Add)
+                        {
+                            success = false;
+
+                            var primaryKey = row.GetPrimaryKey('/') ?? String.Empty;
+
+                            this.Messaging.Write(ErrorMessages.NewRowAddedInTable(row.SourceLineNumbers, productCode, table.Name, primaryKey));
+                        }
+                    }
+                }
+            }
+
+            return success;
+        }
+
+        /// <summary>
+        /// Reduce the transform according to the patch references.
+        /// </summary>
+        /// <param name="transform">transform generated by torch.</param>
+        /// <param name="patchRefTuples">Table contains patch family filter.</param>
+        /// <returns>true if the transform is not empty</returns>
+        private bool ReduceTransform(WindowsInstallerData transform, IEnumerable<WixPatchRefTuple> patchRefTuples)
+        {
+            // identify sections to keep
+            var oldSections = new Dictionary<string, Row>();
+            var newSections = new Dictionary<string, Row>();
+            var tableKeyRows = new Dictionary<string, Dictionary<string, Row>>();
+            var sequenceList = new List<Table>();
+            var componentFeatureAddsIndex = new Dictionary<string, List<string>>();
+            var customActionTable = new Dictionary<string, Row>();
+            var directoryTableAdds = new Dictionary<string, Row>();
+            var featureTableAdds = new Dictionary<string, Row>();
+            var keptComponents = new Dictionary<string, Row>();
+            var keptDirectories = new Dictionary<string, Row>();
+            var keptFeatures = new Dictionary<string, Row>();
+            var keptLockPermissions = new HashSet<string>();
+            var keptMsiLockPermissionExs = new HashSet<string>();
+
+            var componentCreateFolderIndex = new Dictionary<string, List<string>>();
+            var directoryLockPermissionsIndex = new Dictionary<string, List<Row>>();
+            var directoryMsiLockPermissionsExIndex = new Dictionary<string, List<Row>>();
+
+            foreach (var patchRefTuple in patchRefTuples)
+            {
+                var tableName = patchRefTuple.Table;
+                var key = patchRefTuple.PrimaryKeys;
+
+                // Short circuit filtering if all changes should be included.
+                if ("*" == tableName && "*" == key)
+                {
+                    RemoveProductCodeFromTransform(transform);
+                    return true;
+                }
+
+                if (!transform.Tables.TryGetTable(tableName, out var table))
+                {
+                    // Table not found.
+                    continue;
+                }
+
+                // Index the table.
+                if (!tableKeyRows.TryGetValue(tableName, out var keyRows))
+                {
+                    keyRows = new Dictionary<string, Row>();
+                    tableKeyRows.Add(tableName, keyRows);
+
+                    foreach (var newRow in table.Rows)
+                    {
+                        var primaryKey = newRow.GetPrimaryKey();
+                        keyRows.Add(primaryKey, newRow);
+                    }
+                }
+
+                if (!keyRows.TryGetValue(key, out var row))
+                {
+                    // Row not found.
+                    continue;
+                }
+
+                // Differ.sectionDelimiter
+                var sections = row.SectionId.Split('/');
+                oldSections[sections[0]] = row;
+                newSections[sections[1]] = row;
+            }
+
+            // throw away sections not referenced
+            var keptRows = 0;
+            Table directoryTable = null;
+            Table featureTable = null;
+            Table lockPermissionsTable = null;
+            Table msiLockPermissionsTable = null;
+
+            foreach (var table in transform.Tables)
+            {
+                if ("_SummaryInformation" == table.Name)
+                {
+                    continue;
+                }
+
+                if (table.Name == "AdminExecuteSequence"
+                    || table.Name == "AdminUISequence"
+                    || table.Name == "AdvtExecuteSequence"
+                    || table.Name == "InstallUISequence"
+                    || table.Name == "InstallExecuteSequence")
+                {
+                    sequenceList.Add(table);
+                    continue;
+                }
+
+                for (var i = 0; i < table.Rows.Count; i++)
+                {
+                    var row = table.Rows[i];
+
+                    if (table.Name == "CreateFolder")
+                    {
+                        var createFolderComponentId = row.FieldAsString(1);
+
+                        if (!componentCreateFolderIndex.TryGetValue(createFolderComponentId, out var directoryList))
+                        {
+                            directoryList = new List<string>();
+                            componentCreateFolderIndex.Add(createFolderComponentId, directoryList);
+                        }
+
+                        directoryList.Add(row.FieldAsString(0));
+                    }
+
+                    if (table.Name == "CustomAction")
+                    {
+                        customActionTable.Add(row.FieldAsString(0), row);
+                    }
+
+                    if (table.Name == "Directory")
+                    {
+                        directoryTable = table;
+                        if (RowOperation.Add == row.Operation)
+                        {
+                            directoryTableAdds.Add(row.FieldAsString(0), row);
+                        }
+                    }
+
+                    if (table.Name == "Feature")
+                    {
+                        featureTable = table;
+                        if (RowOperation.Add == row.Operation)
+                        {
+                            featureTableAdds.Add(row.FieldAsString(0), row);
+                        }
+                    }
+
+                    if (table.Name == "FeatureComponents")
+                    {
+                        if (RowOperation.Add == row.Operation)
+                        {
+                            var featureId = row.FieldAsString(0);
+                            var componentId = row.FieldAsString(1);
+
+                            if (!componentFeatureAddsIndex.TryGetValue(componentId, out var featureList))
+                            {
+                                featureList = new List<string>();
+                                componentFeatureAddsIndex.Add(componentId, featureList);
+                            }
+
+                            featureList.Add(featureId);
+                        }
+                    }
+
+                    if (table.Name == "LockPermissions")
+                    {
+                        lockPermissionsTable = table;
+                        if ("CreateFolder" == row.FieldAsString(1))
+                        {
+                            var directoryId = row.FieldAsString(0);
+
+                            if (!directoryLockPermissionsIndex.TryGetValue(directoryId, out var rowList))
+                            {
+                                rowList = new List<Row>();
+                                directoryLockPermissionsIndex.Add(directoryId, rowList);
+                            }
+
+                            rowList.Add(row);
+                        }
+                    }
+
+                    if (table.Name == "MsiLockPermissionsEx")
+                    {
+                        msiLockPermissionsTable = table;
+                        if ("CreateFolder" == row.FieldAsString(1))
+                        {
+                            var directoryId = row.FieldAsString(0);
+
+                            if (!directoryMsiLockPermissionsExIndex.TryGetValue(directoryId, out var rowList))
+                            {
+                                rowList = new List<Row>();
+                                directoryMsiLockPermissionsExIndex.Add(directoryId, rowList);
+                            }
+
+                            rowList.Add(row);
+                        }
+                    }
+
+                    if (null == row.SectionId)
+                    {
+                        table.Rows.RemoveAt(i);
+                        i--;
+                    }
+                    else
+                    {
+                        var sections = row.SectionId.Split('/');
+                        // ignore the row without section id.
+                        if (0 == sections[0].Length && 0 == sections[1].Length)
+                        {
+                            table.Rows.RemoveAt(i);
+                            i--;
+                        }
+                        else if (IsInPatchFamily(sections[0], sections[1], oldSections, newSections))
+                        {
+                            if ("Component" == table.Name)
+                            {
+                                keptComponents.Add(row.FieldAsString(0), row);
+                            }
+
+                            if ("Directory" == table.Name)
+                            {
+                                keptDirectories.Add(row.FieldAsString(0), row);
+                            }
+
+                            if ("Feature" == table.Name)
+                            {
+                                keptFeatures.Add(row.FieldAsString(0), row);
+                            }
+
+                            keptRows++;
+                        }
+                        else
+                        {
+                            table.Rows.RemoveAt(i);
+                            i--;
+                        }
+                    }
+                }
+            }
+
+            keptRows += ReduceTransformSequenceTable(sequenceList, oldSections, newSections, customActionTable);
+
+            if (null != directoryTable)
+            {
+                foreach (var componentRow in keptComponents.Values)
+                {
+                    var componentId = componentRow.FieldAsString(0);
+
+                    if (RowOperation.Add == componentRow.Operation)
+                    {
+                        // Make sure each added component has its required directory and feature heirarchy.
+                        var directoryId = componentRow.FieldAsString(2);
+                        while (null != directoryId && directoryTableAdds.TryGetValue(directoryId, out var directoryRow))
+                        {
+                            if (!keptDirectories.ContainsKey(directoryId))
+                            {
+                                directoryTable.Rows.Add(directoryRow);
+                                keptDirectories.Add(directoryId, directoryRow);
+                                keptRows++;
+                            }
+
+                            directoryId = directoryRow.FieldAsString(1);
+                        }
+
+                        if (componentFeatureAddsIndex.TryGetValue(componentId, out var componentFeatureIds))
+                        {
+                            foreach (var featureId in componentFeatureIds)
+                            {
+                                var currentFeatureId = featureId;
+                                while (null != currentFeatureId && featureTableAdds.TryGetValue(currentFeatureId, out var featureRow))
+                                {
+                                    if (!keptFeatures.ContainsKey(currentFeatureId))
+                                    {
+                                        featureTable.Rows.Add(featureRow);
+                                        keptFeatures.Add(currentFeatureId, featureRow);
+                                        keptRows++;
+                                    }
+
+                                    currentFeatureId = featureRow.FieldAsString(1);
+                                }
+                            }
+                        }
+                    }
+
+                    // Hook in changes LockPermissions and MsiLockPermissions for folders for each component that has been kept.
+                    foreach (var keptComponentId in keptComponents.Keys)
+                    {
+                        if (componentCreateFolderIndex.TryGetValue(keptComponentId, out var directoryList))
+                        {
+                            foreach (var directoryId in directoryList)
+                            {
+                                if (directoryLockPermissionsIndex.TryGetValue(directoryId, out var lockPermissionsRowList))
+                                {
+                                    foreach (var lockPermissionsRow in lockPermissionsRowList)
+                                    {
+                                        var key = lockPermissionsRow.GetPrimaryKey('/');
+                                        if (keptLockPermissions.Add(key))
+                                        {
+                                            lockPermissionsTable.Rows.Add(lockPermissionsRow);
+                                            keptRows++;
+                                        }
+                                    }
+                                }
+
+                                if (directoryMsiLockPermissionsExIndex.TryGetValue(directoryId, out var msiLockPermissionsExRowList))
+                                {
+                                    foreach (var msiLockPermissionsExRow in msiLockPermissionsExRowList)
+                                    {
+                                        var key = msiLockPermissionsExRow.GetPrimaryKey('/');
+                                        if (keptMsiLockPermissionExs.Add(key))
+                                        {
+                                            msiLockPermissionsTable.Rows.Add(msiLockPermissionsExRow);
+                                            keptRows++;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            keptRows += ReduceTransformSequenceTable(sequenceList, oldSections, newSections, customActionTable);
+
+            // Delete tables that are empty.
+            var tablesToDelete = transform.Tables.Where(t => t.Rows.Count == 0).Select(t => t.Name);
+
+            foreach (var tableName in tablesToDelete)
+            {
+                transform.Tables.Remove(tableName);
+            }
+
+            return keptRows > 0;
+        }
+
+        private void Validate(PatchTransform patchTransform)
+        {
+            var transformPath = patchTransform.Baseline; // TODO: this is used in error messages, how best to set it?
+            var transform = patchTransform.Transform;
+
+            // Changing the ProdocutCode in a patch transform is not recommended.
+            if (transform.TryGetTable("Property", out var propertyTable))
+            {
+                foreach (var row in propertyTable.Rows)
+                {
+                    // Only interested in modified rows; fast check.
+                    if (RowOperation.Modify == row.Operation &&
+                        "ProductCode".Equals(row.FieldAsString(0), StringComparison.Ordinal))
+                    {
+                        this.Messaging.Write(WarningMessages.MajorUpgradePatchNotRecommended());
+                    }
+                }
+            }
+
+            // If there is nothing in the component table we can return early because the remaining checks are component based.
+            if (!transform.TryGetTable("Component", out var componentTable))
+            {
+                return;
+            }
+
+            // Index Feature table row operations
+            var featureOps = new Dictionary<string, RowOperation>();
+            if (transform.TryGetTable("Feature", out var featureTable))
+            {
+                foreach (var row in featureTable.Rows)
+                {
+                    featureOps[row.FieldAsString(0)] = row.Operation;
+                }
+            }
+
+            // Index Component table and check for keypath modifications
+            var componentKeyPath = new Dictionary<string, string>();
+            var deletedComponent = new Dictionary<string, Row>();
+            foreach (var row in componentTable.Rows)
+            {
+                var id = row.FieldAsString(0);
+                var keypath = row.FieldAsString(5) ?? String.Empty;
+
+                componentKeyPath.Add(id, keypath);
+
+                if (RowOperation.Delete == row.Operation)
+                {
+                    deletedComponent.Add(id, row);
+                }
+                else if (RowOperation.Modify == row.Operation)
+                {
+                    if (row.Fields[1].Modified)
+                    {
+                        // Changing the guid of a component is equal to deleting the old one and adding a new one.
+                        deletedComponent.Add(id, row);
+                    }
+
+                    // If the keypath is modified its an error
+                    if (row.Fields[5].Modified)
+                    {
+                        this.Messaging.Write(ErrorMessages.InvalidKeypathChange(row.SourceLineNumbers, id, transformPath));
+                    }
+                }
+            }
+
+            // Verify changes in the file table
+            if (transform.TryGetTable("File", out var fileTable))
+            {
+                var componentWithChangedKeyPath = new Dictionary<string, string>();
+                foreach (var row in fileTable.Rows)
+                {
+                    if (RowOperation.None == row.Operation)
+                    {
+                        continue;
+                    }
+
+                    var fileId = row.FieldAsString(0);
+                    var componentId = row.FieldAsString(1);
+
+                    // If this file is the keypath of a component
+                    if (componentKeyPath.TryGetValue(componentId, out var keyPath) && keyPath.Equals(fileId, StringComparison.Ordinal))
+                    {
+                        if (row.Fields[2].Modified)
+                        {
+                            // You can't change the filename of a file that is the keypath of a component.
+                            this.Messaging.Write(ErrorMessages.InvalidKeypathChange(row.SourceLineNumbers, componentId, transformPath));
+                        }
+
+                        if (!componentWithChangedKeyPath.ContainsKey(componentId))
+                        {
+                            componentWithChangedKeyPath.Add(componentId, fileId);
+                        }
+                    }
+
+                    if (RowOperation.Delete == row.Operation)
+                    {
+                        // If the file is removed from a component that is not deleted.
+                        if (!deletedComponent.ContainsKey(componentId))
+                        {
+                            var foundRemoveFileEntry = false;
+                            var filename = Common.GetName(row.FieldAsString(2), false, true);
+
+                            if (transform.TryGetTable("RemoveFile", out var removeFileTable))
+                            {
+                                foreach (var removeFileRow in removeFileTable.Rows)
+                                {
+                                    if (RowOperation.Delete == removeFileRow.Operation)
+                                    {
+                                        continue;
+                                    }
+
+                                    if (componentId == removeFileRow.FieldAsString(1))
+                                    {
+                                        // Check if there is a RemoveFile entry for this file
+                                        if (null != removeFileRow[2])
+                                        {
+                                            var removeFileName = Common.GetName(removeFileRow.FieldAsString(2), false, true);
+
+                                            // Convert the MSI format for a wildcard string to Regex format.
+                                            removeFileName = removeFileName.Replace('.', '|').Replace('?', '.').Replace("*", ".*").Replace("|", "\\.");
+
+                                            var regex = new Regex(removeFileName, RegexOptions.CultureInvariant | RegexOptions.IgnoreCase);
+                                            if (regex.IsMatch(filename))
+                                            {
+                                                foundRemoveFileEntry = true;
+                                                break;
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+
+                            if (!foundRemoveFileEntry)
+                            {
+                                this.Messaging.Write(WarningMessages.InvalidRemoveFile(row.SourceLineNumbers, fileId, componentId));
+                            }
+                        }
+                    }
+                }
+            }
+
+            var featureComponentsTable = transform.Tables["FeatureComponents"];
+
+            if (0 < deletedComponent.Count)
+            {
+                // Index FeatureComponents table.
+                var featureComponents = new Dictionary<string, List<string>>();
+
+                if (null != featureComponentsTable)
+                {
+                    foreach (var row in featureComponentsTable.Rows)
+                    {
+                        var componentId = row.FieldAsString(1);
+
+                        if (!featureComponents.TryGetValue(componentId, out var features))
+                        {
+                            features = new List<string>();
+                            featureComponents.Add(componentId, features);
+                        }
+
+                        features.Add(row.FieldAsString(0));
+                    }
+                }
+
+                // Check to make sure if a component was deleted, the feature was too.
+                foreach (var entry in deletedComponent)
+                {
+                    if (featureComponents.TryGetValue(entry.Key, out var features))
+                    {
+                        foreach (var featureId in features)
+                        {
+                            if (!featureOps.TryGetValue(featureId, out var op) || op != RowOperation.Delete)
+                            {
+                                // The feature was not deleted.
+                                this.Messaging.Write(ErrorMessages.InvalidRemoveComponent(((Row)entry.Value).SourceLineNumbers, entry.Key.ToString(), featureId, transformPath));
+                            }
+                        }
+                    }
+                }
+            }
+
+            // Warn if new components are added to existing features
+            if (null != featureComponentsTable)
+            {
+                foreach (var row in featureComponentsTable.Rows)
+                {
+                    if (RowOperation.Add == row.Operation)
+                    {
+                        // Check if the feature is in the Feature table
+                        var feature_ = row.FieldAsString(0);
+                        var component_ = row.FieldAsString(1);
+
+                        // Features may not be present if not referenced
+                        if (!featureOps.ContainsKey(feature_) || RowOperation.Add != (RowOperation)featureOps[feature_])
+                        {
+                            this.Messaging.Write(WarningMessages.NewComponentAddedToExistingFeature(row.SourceLineNumbers, component_, feature_, transformPath));
+                        }
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Remove the ProductCode property from the transform.
+        /// </summary>
+        /// <param name="transform">The transform.</param>
+        /// <remarks>
+        /// Changing the ProductCode is not supported in a patch.
+        /// </remarks>
+        private static void RemoveProductCodeFromTransform(WindowsInstallerData transform)
+        {
+            if (transform.Tables.TryGetTable("Property", out var propertyTable))
+            {
+                for (var i = 0; i < propertyTable.Rows.Count; ++i)
+                {
+                    var propertyRow = propertyTable.Rows[i];
+                    var property = (string)propertyRow[0];
+
+                    if ("ProductCode" == property)
+                    {
+                        propertyTable.Rows.RemoveAt(i);
+                        break;
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Check if the section is in a PatchFamily.
+        /// </summary>
+        /// <param name="oldSection">Section id in target wixout</param>
+        /// <param name="newSection">Section id in upgrade wixout</param>
+        /// <param name="oldSections">Dictionary contains section id should be kept in the baseline wixout.</param>
+        /// <param name="newSections">Dictionary contains section id should be kept in the upgrade wixout.</param>
+        /// <returns>true if section in patch family</returns>
+        private static bool IsInPatchFamily(string oldSection, string newSection, Dictionary<string, Row> oldSections, Dictionary<string, Row> newSections)
+        {
+            var result = false;
+
+            if ((String.IsNullOrEmpty(oldSection) && newSections.ContainsKey(newSection)) || (String.IsNullOrEmpty(newSection) && oldSections.ContainsKey(oldSection)))
+            {
+                result = true;
+            }
+            else if (!String.IsNullOrEmpty(oldSection) && !String.IsNullOrEmpty(newSection) && (oldSections.ContainsKey(oldSection) || newSections.ContainsKey(newSection)))
+            {
+                result = true;
+            }
+
+            return result;
+        }
+
+        /// <summary>
+        /// Reduce the transform sequence tables.
+        /// </summary>
+        /// <param name="sequenceList">ArrayList of tables to be reduced</param>
+        /// <param name="oldSections">Hashtable contains section id should be kept in the baseline wixout.</param>
+        /// <param name="newSections">Hashtable contains section id should be kept in the target wixout.</param>
+        /// <param name="customAction">Hashtable contains all the rows in the CustomAction table.</param>
+        /// <returns>Number of rows left</returns>
+        private static int ReduceTransformSequenceTable(List<Table> sequenceList, Dictionary<string, Row> oldSections, Dictionary<string, Row> newSections, Dictionary<string, Row> customAction)
+        {
+            var keptRows = 0;
+
+            foreach (var currentTable in sequenceList)
+            {
+                for (var i = 0; i < currentTable.Rows.Count; i++)
+                {
+                    var row = currentTable.Rows[i];
+                    var actionName = row.Fields[0].Data.ToString();
+                    var sections = row.SectionId.Split('/');
+                    var isSectionIdEmpty = (sections[0].Length == 0 && sections[1].Length == 0);
+
+                    if (row.Operation == RowOperation.None)
+                    {
+                        // ignore the rows without section id.
+                        if (isSectionIdEmpty)
+                        {
+                            currentTable.Rows.RemoveAt(i);
+                            i--;
+                        }
+                        else if (IsInPatchFamily(sections[0], sections[1], oldSections, newSections))
+                        {
+                            keptRows++;
+                        }
+                        else
+                        {
+                            currentTable.Rows.RemoveAt(i);
+                            i--;
+                        }
+                    }
+                    else if (row.Operation == RowOperation.Modify)
+                    {
+                        var sequenceChanged = row.Fields[2].Modified;
+                        var conditionChanged = row.Fields[1].Modified;
+
+                        if (sequenceChanged && !conditionChanged)
+                        {
+                            keptRows++;
+                        }
+                        else if (!sequenceChanged && conditionChanged)
+                        {
+                            if (isSectionIdEmpty)
+                            {
+                                currentTable.Rows.RemoveAt(i);
+                                i--;
+                            }
+                            else if (IsInPatchFamily(sections[0], sections[1], oldSections, newSections))
+                            {
+                                keptRows++;
+                            }
+                            else
+                            {
+                                currentTable.Rows.RemoveAt(i);
+                                i--;
+                            }
+                        }
+                        else if (sequenceChanged && conditionChanged)
+                        {
+                            if (isSectionIdEmpty)
+                            {
+                                row.Fields[1].Modified = false;
+                                keptRows++;
+                            }
+                            else if (IsInPatchFamily(sections[0], sections[1], oldSections, newSections))
+                            {
+                                keptRows++;
+                            }
+                            else
+                            {
+                                row.Fields[1].Modified = false;
+                                keptRows++;
+                            }
+                        }
+                    }
+                    else if (row.Operation == RowOperation.Delete)
+                    {
+                        if (isSectionIdEmpty)
+                        {
+                            // it is a stardard action which is added by wix, we should keep this action.
+                            row.Operation = RowOperation.None;
+                            keptRows++;
+                        }
+                        else if (IsInPatchFamily(sections[0], sections[1], oldSections, newSections))
+                        {
+                            keptRows++;
+                        }
+                        else
+                        {
+                            if (customAction.ContainsKey(actionName))
+                            {
+                                currentTable.Rows.RemoveAt(i);
+                                i--;
+                            }
+                            else
+                            {
+                                // it is a stardard action, we should keep this action.
+                                row.Operation = RowOperation.None;
+                                keptRows++;
+                            }
+                        }
+                    }
+                    else if (row.Operation == RowOperation.Add)
+                    {
+                        if (isSectionIdEmpty)
+                        {
+                            keptRows++;
+                        }
+                        else if (IsInPatchFamily(sections[0], sections[1], oldSections, newSections))
+                        {
+                            keptRows++;
+                        }
+                        else
+                        {
+                            if (customAction.ContainsKey(actionName))
+                            {
+                                currentTable.Rows.RemoveAt(i);
+                                i--;
+                            }
+                            else
+                            {
+                                keptRows++;
+                            }
+                        }
+                    }
+                }
+            }
+
+            return keptRows;
+        }
+
+        /// <summary>
+        /// Create the #transform for the given main transform.
+        /// </summary>
+        private WindowsInstallerData BuildPairedTransform(Dictionary<SumaryInformationType, SummaryInformationTuple> summaryInfo, Dictionary<string, MsiPatchMetadataTuple> patchMetadata, WixPatchIdTuple patchIdTuple, WindowsInstallerData mainTransform, MediaTuple mediaTuple, WixPatchBaselineTuple baselineTuple, out string productCode)
+        {
+            productCode = null;
+
+            var pairedTransform = new WindowsInstallerData(null)
+            {
+                Type = OutputType.Transform,
+                Codepage = mainTransform.Codepage
+            };
+
+            // lookup productVersion property to correct summaryInformation
+            var newProductVersion = mainTransform.Tables["Property"]?.Rows.FirstOrDefault(r => r.FieldAsString(0) == "ProductVersion")?.FieldAsString(1);
+
+            var mainSummaryTable = mainTransform.Tables["_SummaryInformation"];
+            var mainSummaryRows = mainSummaryTable.Rows.ToDictionary(r => r.FieldAsInteger(0));
+
+            var baselineValidationFlags = ((int)baselineTuple.ValidationFlags).ToString(CultureInfo.InvariantCulture);
+
+            if (!mainSummaryRows.ContainsKey((int)SumaryInformationType.TransformValidationFlags))
+            {
+                var mainSummaryRow = mainSummaryTable.CreateRow(baselineTuple.SourceLineNumbers);
+                mainSummaryRow[0] = (int)SumaryInformationType.TransformValidationFlags;
+                mainSummaryRow[1] = baselineValidationFlags;
+            }
+
+            // copy summary information from core transform
+            var pairedSummaryTable = pairedTransform.EnsureTable(this.tableDefinitions["_SummaryInformation"]);
+
+            foreach (var mainSummaryRow in mainSummaryTable.Rows)
+            {
+                var type = (SumaryInformationType)mainSummaryRow.FieldAsInteger(0);
+                var value = mainSummaryRow.FieldAsString(1);
+                switch (type)
+                {
+                    case SumaryInformationType.TransformProductCodes:
+                        var propertyData = value.Split(';');
+                        var oldProductVersion = propertyData[0].Substring(38);
+                        var upgradeCode = propertyData[2];
+                        productCode = propertyData[0].Substring(0, 38);
+
+                        if (newProductVersion == null)
+                        {
+                            newProductVersion = oldProductVersion;
+                        }
+
+                        // Force mainTranform to 'old;new;upgrade' and pairedTransform to 'new;new;upgrade'
+                        mainSummaryRow[1] = String.Concat(productCode, oldProductVersion, ';', productCode, newProductVersion, ';', upgradeCode);
+                        value = String.Concat(productCode, newProductVersion, ';', productCode, newProductVersion, ';', upgradeCode);
+                        break;
+                    case SumaryInformationType.TransformValidationFlags: // use validation flags authored into the patch XML.
+                        value = baselineValidationFlags;
+                        mainSummaryRow[1] = value;
+                        break;
+                }
+
+                var pairedSummaryRow = pairedSummaryTable.CreateRow(mainSummaryRow.SourceLineNumbers);
+                pairedSummaryRow[0] = mainSummaryRow[0];
+                pairedSummaryRow[1] = value;
+            }
+
+            if (productCode == null)
+            {
+                this.Messaging.Write(ErrorMessages.CouldNotDetermineProductCodeFromTransformSummaryInfo());
+                return null;
+            }
+
+            // copy File table
+            if (mainTransform.Tables.TryGetTable("File", out var mainFileTable) && 0 < mainFileTable.Rows.Count)
+            {
+#if TODO_PATCHING
+                // We require file source information.
+                var mainWixFileTable = mainTransform.Tables["WixFile"];
+                if (null == mainWixFileTable)
+                {
+                    this.Messaging.Write(ErrorMessages.AdminImageRequired(productCode));
+                    return null;
+                }
+
+                var mainFileRows = new RowDictionary<FileRow>(mainFileTable);
+
+                var pairedFileTable = pairedTransform.EnsureTable(mainFileTable.Definition);
+                {
+                    var mainFileRow = mainFileRows[mainWixFileRow.File];
+
+                    // set File.Sequence to non null to satisfy transform bind
+                    mainFileRow.Sequence = 1;
+
+                    // delete's don't need rows in the paired transform
+                    if (mainFileRow.Operation == RowOperation.Delete)
+                    {
+                        continue;
+                    }
+
+                    var pairedFileRow = (FileRow)pairedFileTable.CreateRow(null);
+                    pairedFileRow.Operation = RowOperation.Modify;
+                    for (var i = 0; i < mainFileRow.Fields.Length; i++)
+                    {
+                        pairedFileRow[i] = mainFileRow[i];
+                    }
+
+                    // override authored media for patch bind
+                    mainWixFileRow.DiskId = mediaTuple.DiskId;
+
+                    // suppress any change to File.Sequence to avoid bloat
+                    mainFileRow.Fields[7].Modified = false;
+
+                    // force File row to appear in the transform
+                    switch (mainFileRow.Operation)
+                    {
+                        case RowOperation.Modify:
+                        case RowOperation.Add:
+                            pairedFileRow.Attributes |= WindowsInstallerConstants.MsidbFileAttributesPatchAdded;
+                            pairedFileRow.Fields[6].Modified = true;
+                            pairedFileRow.Operation = mainFileRow.Operation;
+                            break;
+                        default:
+                            pairedFileRow.Fields[6].Modified = false;
+                            break;
+                    }
+                }
+#endif
+            }
+
+            // Add Media row to pairedTransform
+            var pairedMediaTable = pairedTransform.EnsureTable(this.tableDefinitions["Media"]);
+            var pairedMediaRow = pairedMediaTable.CreateRow(mediaTuple.SourceLineNumbers);
+            pairedMediaRow.Operation = RowOperation.Add;
+            pairedMediaRow[0] = mediaTuple.DiskId;
+            pairedMediaRow[1] = mediaTuple.LastSequence ?? 0;
+            pairedMediaRow[2] = mediaTuple.DiskPrompt;
+            pairedMediaRow[3] = mediaTuple.Cabinet;
+            pairedMediaRow[4] = mediaTuple.VolumeLabel;
+            pairedMediaRow[5] = mediaTuple.Source;
+
+            // Add PatchPackage for this Media
+            var pairedPackageTable = pairedTransform.EnsureTable(this.tableDefinitions["PatchPackage"]);
+            pairedPackageTable.Operation = TableOperation.Add;
+            var pairedPackageRow = pairedPackageTable.CreateRow(mediaTuple.SourceLineNumbers);
+            pairedPackageRow.Operation = RowOperation.Add;
+            pairedPackageRow[0] = patchIdTuple.Id.Id;
+            pairedPackageRow[1] = mediaTuple.DiskId;
+
+            // Add the property to the patch transform's Property table.
+            var pairedPropertyTable = pairedTransform.EnsureTable(this.tableDefinitions["Property"]);
+            pairedPropertyTable.Operation = TableOperation.Add;
+
+            // Add property to both identify client patches and whether those patches are removable or not
+            patchMetadata.TryGetValue("AllowRemoval", out var allowRemovalTuple);
+
+            var pairedPropertyRow = pairedPropertyTable.CreateRow(allowRemovalTuple?.SourceLineNumbers);
+            pairedPropertyRow.Operation = RowOperation.Add;
+            pairedPropertyRow[0] = String.Concat(patchIdTuple.ClientPatchId, ".AllowRemoval");
+            pairedPropertyRow[1] = allowRemovalTuple?.Value ?? "0";
+
+            // Add this patch code GUID to the patch transform to identify
+            // which patches are installed, including in multi-patch
+            // installations.
+            pairedPropertyRow = pairedPropertyTable.CreateRow(patchIdTuple.SourceLineNumbers);
+            pairedPropertyRow.Operation = RowOperation.Add;
+            pairedPropertyRow[0] = String.Concat(patchIdTuple.ClientPatchId, ".PatchCode");
+            pairedPropertyRow[1] = patchIdTuple.Id.Id;
+
+            // Add PATCHNEWPACKAGECODE to apply to admin layouts.
+            pairedPropertyRow = pairedPropertyTable.CreateRow(patchIdTuple.SourceLineNumbers);
+            pairedPropertyRow.Operation = RowOperation.Add;
+            pairedPropertyRow[0] = "PATCHNEWPACKAGECODE";
+            pairedPropertyRow[1] = patchIdTuple.Id.Id;
+
+            // Add PATCHNEWSUMMARYCOMMENTS and PATCHNEWSUMMARYSUBJECT to apply to admin layouts.
+            if (summaryInfo.TryGetValue(SumaryInformationType.Subject, out var subjectTuple))
+            {
+                pairedPropertyRow = pairedPropertyTable.CreateRow(subjectTuple.SourceLineNumbers);
+                pairedPropertyRow.Operation = RowOperation.Add;
+                pairedPropertyRow[0] = "PATCHNEWSUMMARYSUBJECT";
+                pairedPropertyRow[1] = subjectTuple.Value;
+            }
+
+            if (summaryInfo.TryGetValue(SumaryInformationType.Comments, out var commentsTuple))
+            {
+                pairedPropertyRow = pairedPropertyTable.CreateRow(commentsTuple.SourceLineNumbers);
+                pairedPropertyRow.Operation = RowOperation.Add;
+                pairedPropertyRow[0] = "PATCHNEWSUMMARYCOMMENTS";
+                pairedPropertyRow[1] = commentsTuple.Value;
+            }
+
+            return pairedTransform;
+        }
+
+        private static SortedSet<string> FinalizePatchProductCodes(List<IntermediateTuple> tuples, SortedSet<string> productCodes)
+        {
+            var patchTargetTuples = tuples.OfType<WixPatchTargetTuple>().ToList();
+
+            if (patchTargetTuples.Count > 0)
+            {
+                var targets = new SortedSet<string>();
+                var replace = true;
+                foreach (var wixPatchTargetRow in patchTargetTuples)
+                {
+                    var target = wixPatchTargetRow.ProductCode.ToUpperInvariant();
+                    if (target == "*")
+                    {
+                        replace = false;
+                    }
+                    else
+                    {
+                        targets.Add(target);
+                    }
+                }
+
+                // Replace the target ProductCodes with the authored list.
+                if (replace)
+                {
+                    productCodes = targets;
+                }
+                else
+                {
+                    // Copy the authored target ProductCodes into the list.
+                    foreach (var target in targets)
+                    {
+                        productCodes.Add(target);
+                    }
+                }
+            }
+
+            return productCodes;
+        }
+    }
+}
diff --git a/src/WixToolset.Core.WindowsInstaller/Bind/BindDatabaseCommand.cs b/src/WixToolset.Core.WindowsInstaller/Bind/BindDatabaseCommand.cs
index 175203ce..34104ef5 100644
--- a/src/WixToolset.Core.WindowsInstaller/Bind/BindDatabaseCommand.cs
+++ b/src/WixToolset.Core.WindowsInstaller/Bind/BindDatabaseCommand.cs
@@ -24,7 +24,11 @@ namespace WixToolset.Core.WindowsInstaller.Bind
 
         private bool disposed;
 
-        public BindDatabaseCommand(IBindContext context, IEnumerable<IWindowsInstallerBackendBinderExtension> backendExtension, Validator validator)
+        public BindDatabaseCommand(IBindContext context, IEnumerable<IWindowsInstallerBackendBinderExtension> backendExtension, Validator validator):this(context, backendExtension, null, validator)
+        {
+        }
+
+        public BindDatabaseCommand(IBindContext context, IEnumerable<IWindowsInstallerBackendBinderExtension> backendExtension, IEnumerable<SubStorage> subStorages, Validator validator)
         {
             this.ServiceProvider = context.ServiceProvider;
 
@@ -45,6 +49,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             this.OutputPath = context.OutputPath;
             this.OutputPdbPath = context.OutputPdbPath;
             this.IntermediateFolder = context.IntermediateFolder;
+            this.SubStorages = subStorages;
             this.Validator = validator;
 
             this.BackendExtensions = backendExtension;
@@ -76,6 +81,8 @@ namespace WixToolset.Core.WindowsInstaller.Bind
 
         private IEnumerable<IWindowsInstallerBackendBinderExtension> BackendExtensions { get; }
 
+        private IEnumerable<SubStorage> SubStorages { get; }
+
         private Intermediate Intermediate { get; }
 
         private string OutputPath { get; }
@@ -112,18 +119,10 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             // Load standard tables, authored custom tables, and extension custom tables.
             TableDefinitionCollection tableDefinitions;
             {
-                var command = new LoadTableDefinitionsCommand(section);
+                var command = new LoadTableDefinitionsCommand(section, this.BackendExtensions);
                 command.Execute();
 
                 tableDefinitions = command.TableDefinitions;
-
-                foreach (var backendExtension in this.BackendExtensions)
-                {
-                    foreach (var tableDefinition in backendExtension.TableDefinitions)
-                    {
-                        tableDefinitions.Add(tableDefinition);
-                    }
-                }
             }
 
             // Process the summary information table before the other tables.
@@ -186,8 +185,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
 
             // Sequence all the actions.
             {
-                var command = new SequenceActionsCommand(section);
-                command.Messaging = this.Messaging;
+                var command = new SequenceActionsCommand(this.Messaging, section);
                 command.Execute();
             }
 
@@ -196,7 +194,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                 command.Execute();
             }
 
-#if TODO_FINISH_PATCH
+#if TODO_PATCHING
             ////if (OutputType.Patch == this.Output.Type)
             ////{
             ////    foreach (SubStorage substorage in this.Output.SubStorages)
@@ -223,130 +221,162 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                 return;
             }
 
-            this.Messaging.Write(VerboseMessages.UpdatingFileInformation());
+            // Call extension
+            var ExtensionSaidSkip = false;
 
-            // This must occur after all variables and source paths have been resolved.
-            List<FileFacade> fileFacades;
+            WindowsInstallerData output;
+            if (ExtensionSaidSkip)
             {
-                var command = new GetFileFacadesCommand(section);
+                // Time to create the output object, since we're bypassing everything that touches files.
+                var command = new CreateOutputFromIRCommand(this.Messaging, section, tableDefinitions, this.BackendExtensions);
                 command.Execute();
 
-                fileFacades = command.FileFacades;
+                output = command.Output;
             }
-
-            // Extract files that come from binary .wixlibs and WixExtensions (this does not extract files from merge modules).
+            else
             {
-                var command = new ExtractEmbeddedFilesCommand(this.ExpectedEmbeddedFiles);
-                command.Execute();
-            }
+                this.Messaging.Write(VerboseMessages.UpdatingFileInformation());
 
-            // Gather information about files that do not come from merge modules.
-            {
-                var command = new UpdateFileFacadesCommand(this.Messaging, section);
-                command.FileFacades = fileFacades;
-                command.UpdateFileFacades = fileFacades.Where(f => !f.FromModule);
-                command.OverwriteHash = true;
-                command.TableDefinitions = tableDefinitions;
-                command.VariableCache = variableCache;
-                command.Execute();
-            }
+                // Extract files that come from binary .wixlibs and WixExtensions (this does not extract files from merge modules).
+                {
+                    var command = new ExtractEmbeddedFilesCommand(this.ExpectedEmbeddedFiles);
+                    command.Execute();
+                }
 
-            // Now that the variable cache is populated, resolve any delayed fields.
-            if (this.DelayedFields.Any())
-            {
-                var command = new ResolveDelayedFieldsCommand(this.Messaging, this.DelayedFields, variableCache);
-                command.Execute();
-            }
+                // This must occur after all variables and source paths have been resolved.
+                List<FileFacade> fileFacades;
+                {
+                    var command = new GetFileFacadesCommand(section);
+                    command.Execute();
 
-            // Set generated component guids.
-            {
-                var command = new CalculateComponentGuids(this.Messaging, this.BackendHelper, this.PathResolver, section);
-                command.Execute();
-            }
+                    fileFacades = command.FileFacades;
+                }
 
-            // Retrieve file information from merge modules.
-            if (SectionType.Product == section.Type)
-            {
-                var wixMergeTuples = section.Tuples.OfType<WixMergeTuple>().ToList();
+                // Retrieve file information from merge modules.
+                if (SectionType.Product == section.Type)
+                {
+                    var wixMergeTuples = section.Tuples.OfType<WixMergeTuple>().ToList();
+
+                    if (wixMergeTuples.Any())
+                    {
+                        containsMergeModules = true;
+
+                        var command = new ExtractMergeModuleFilesCommand(this.Messaging, section, wixMergeTuples);
+                        command.FileFacades = fileFacades;
+                        command.OutputInstallerVersion = installerVersion;
+                        command.SuppressLayout = this.SuppressLayout;
+                        command.IntermediateFolder = this.IntermediateFolder;
+                        command.Execute();
 
-                if (wixMergeTuples.Any())
+                        fileFacades.AddRange(command.MergeModulesFileFacades);
+                    }
+                }
+                else if (SectionType.Patch == section.Type)
                 {
-                    containsMergeModules = true;
+                    // Merge transform data into the output object.
+                    //IEnumerable<FileFacade> filesFromTransform = this.CopyFromTransformData(this.Output);
+
+                    //var command = new CopyTransformDataCommand(this.Messaging, /*output*/this.SubStorages, tableDefinitions, copyOutFileRows: true);
+                    //command.Output = output;
+                    //command.TableDefinitions = this.TableDefinitions;
+                    //command.CopyOutFileRows = true;
+                    var command = new GetFileFacadesFromTransforms(this.Messaging, this.SubStorages, tableDefinitions);
+                    command.Execute();
+                    var filesFromTransforms = command.FileFacades;
 
-                    var command = new ExtractMergeModuleFilesCommand(this.Messaging, section, wixMergeTuples);
+                    fileFacades.AddRange(filesFromTransforms);
+                }
+
+                // stop processing if an error previously occurred
+                if (this.Messaging.EncounteredError)
+                {
+                    return;
+                }
+
+                // Gather information about files that do not come from merge modules.
+                {
+                    var command = new UpdateFileFacadesCommand(this.Messaging, section);
                     command.FileFacades = fileFacades;
-                    command.OutputInstallerVersion = installerVersion;
-                    command.SuppressLayout = this.SuppressLayout;
-                    command.IntermediateFolder = this.IntermediateFolder;
+                    command.UpdateFileFacades = fileFacades.Where(f => !f.FromModule);
+                    command.OverwriteHash = true;
+                    command.TableDefinitions = tableDefinitions;
+                    command.VariableCache = variableCache;
                     command.Execute();
-
-                    fileFacades.AddRange(command.MergeModulesFileFacades);
                 }
-            }
-#if TODO_FINISH_PATCH
-            else if (OutputType.Patch == this.Output.Type)
-            {
-                // Merge transform data into the output object.
-                IEnumerable<FileFacade> filesFromTransform = this.CopyFromTransformData(this.Output);
 
-                fileFacades.AddRange(filesFromTransform);
-            }
-#endif
+                // Assign files to media.
+                Dictionary<int, MediaTuple> assignedMediaRows;
+                Dictionary<MediaTuple, IEnumerable<FileFacade>> filesByCabinetMedia;
+                IEnumerable<FileFacade> uncompressedFiles;
+                {
+                    var command = new AssignMediaCommand(section, this.Messaging);
+                    command.FileFacades = fileFacades;
+                    command.FilesCompressed = compressed;
+                    command.Execute();
 
-            // stop processing if an error previously occurred
-            if (this.Messaging.EncounteredError)
-            {
-                return;
-            }
+                    assignedMediaRows = command.MediaRows;
+                    filesByCabinetMedia = command.FileFacadesByCabinetMedia;
+                    uncompressedFiles = command.UncompressedFileFacades;
+                }
 
-            // Assign files to media.
-            Dictionary<int, MediaTuple> assignedMediaRows;
-            Dictionary<MediaTuple, IEnumerable<FileFacade>> filesByCabinetMedia;
-            IEnumerable<FileFacade> uncompressedFiles;
-            {
-                var command = new AssignMediaCommand(section, this.Messaging);
-                command.FileFacades = fileFacades;
-                command.FilesCompressed = compressed;
-                command.Execute();
+                // stop processing if an error previously occurred
+                if (this.Messaging.EncounteredError)
+                {
+                    return;
+                }
 
-                assignedMediaRows = command.MediaRows;
-                filesByCabinetMedia = command.FileFacadesByCabinetMedia;
-                uncompressedFiles = command.UncompressedFileFacades;
-            }
+                // Now that the variable cache is populated, resolve any delayed fields.
+                if (this.DelayedFields.Any())
+                {
+                    var command = new ResolveDelayedFieldsCommand(this.Messaging, this.DelayedFields, variableCache);
+                    command.Execute();
+                }
 
-            // stop processing if an error previously occurred
-            if (this.Messaging.EncounteredError)
-            {
-                return;
-            }
+                // Set generated component guids.
+                {
+                    var command = new CalculateComponentGuids(this.Messaging, this.BackendHelper, this.PathResolver, section);
+                    command.Execute();
+                }
 
-            // Time to create the output object. Try to put as much above here as possible, updating the IR is better.
-            WindowsInstallerData output;
-            {
-                var command = new CreateOutputFromIRCommand(this.Messaging, section, tableDefinitions, this.BackendExtensions);
-                command.Execute();
+                // stop processing if an error previously occurred
+                if (this.Messaging.EncounteredError)
+                {
+                    return;
+                }
 
-                output = command.Output;
-            }
+                // Time to create the output object. Try to put as much above here as possible, updating the IR is better.
+                {
+                    var command = new CreateOutputFromIRCommand(this.Messaging, section, tableDefinitions, this.BackendExtensions);
+                    command.Execute();
 
-            // Update file sequence.
-            {
-                var command = new UpdateMediaSequencesCommand(output, fileFacades);
-                command.Execute();
-            }
+                    output = command.Output;
+                }
 
-            // Modularize identifiers.
-            if (OutputType.Module == output.Type)
-            {
-                var command = new ModularizeCommand(output, modularizationGuid, section.Tuples.OfType<WixSuppressModularizationTuple>());
-                command.Execute();
-            }
-            else // we can create instance transforms since Component Guids are set.
-            {
+                // Update file sequence.
+                {
+                    var command = new UpdateMediaSequencesCommand(output, fileFacades);
+                    command.Execute();
+                }
+
+                // Modularize identifiers.
+                if (OutputType.Module == output.Type)
+                {
+                    var command = new ModularizeCommand(output, modularizationGuid, section.Tuples.OfType<WixSuppressModularizationTuple>());
+                    command.Execute();
+                }
+                else if (output.Type == OutputType.Patch)
+                {
+                    foreach (var storage in this.SubStorages)
+                    {
+                        output.SubStorages.Add(storage);
+                    }
+                }
+                else // we can create instance transforms since Component Guids are set.
+                {
 #if TODO_FIX_INSTANCE_TRANSFORM
-                this.CreateInstanceTransforms(this.Output);
+                    this.CreateInstanceTransforms(this.Output);
 #endif
-            }
+                }
 
 #if TODO_FINISH_UPDATE
             // Extended binder extensions can be called now that fields are resolved.
@@ -384,116 +414,121 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             }
 #endif
 
-            // Stop processing if an error previously occurred.
-            if (this.Messaging.EncounteredError)
-            {
-                return;
-            }
+                this.ValidateComponentGuids(output);
 
-            // Ensure the intermediate folder is created since delta patches will be
-            // created there.
-            Directory.CreateDirectory(this.IntermediateFolder);
+                // Stop processing if an error previously occurred.
+                if (this.Messaging.EncounteredError)
+                {
+                    return;
+                }
 
-            if (SectionType.Patch == section.Type && this.DeltaBinaryPatch)
-            {
-                var command = new CreateDeltaPatchesCommand(fileFacades, this.IntermediateFolder, section.Tuples.OfType<WixPatchIdTuple>().FirstOrDefault());
-                command.Execute();
-            }
+                // Ensure the intermediate folder is created since delta patches will be
+                // created there.
+                Directory.CreateDirectory(this.IntermediateFolder);
 
-            // create cabinet files and process uncompressed files
-            var layoutDirectory = Path.GetDirectoryName(this.OutputPath);
-            if (!this.SuppressLayout || OutputType.Module == output.Type)
-            {
-                this.Messaging.Write(VerboseMessages.CreatingCabinetFiles());
-
-                var command = new CreateCabinetsCommand(this.ServiceProvider, this.BackendHelper);
-                command.CabbingThreadCount = this.CabbingThreadCount;
-                command.CabCachePath = this.CabCachePath;
-                command.DefaultCompressionLevel = this.DefaultCompressionLevel;
-                command.Output = output;
-                command.Messaging = this.Messaging;
-                command.BackendExtensions = this.BackendExtensions;
-                command.LayoutDirectory = layoutDirectory;
-                command.Compressed = compressed;
-                command.FileRowsByCabinet = filesByCabinetMedia;
-                command.ResolveMedia = this.ResolveMedia;
-                command.TableDefinitions = tableDefinitions;
-                command.TempFilesLocation = this.IntermediateFolder;
-                command.Execute();
+                if (SectionType.Patch == section.Type && this.DeltaBinaryPatch)
+                {
+                    var command = new CreateDeltaPatchesCommand(fileFacades, this.IntermediateFolder, section.Tuples.OfType<WixPatchIdTuple>().FirstOrDefault());
+                    command.Execute();
+                }
 
-                fileTransfers.AddRange(command.FileTransfers);
-                trackedFiles.AddRange(command.TrackedFiles);
-            }
+                // create cabinet files and process uncompressed files
+                var layoutDirectory = Path.GetDirectoryName(this.OutputPath);
+                if (!this.SuppressLayout || OutputType.Module == output.Type)
+                {
+                    this.Messaging.Write(VerboseMessages.CreatingCabinetFiles());
+
+                    var command = new CreateCabinetsCommand(this.ServiceProvider, this.BackendHelper);
+                    command.CabbingThreadCount = this.CabbingThreadCount;
+                    command.CabCachePath = this.CabCachePath;
+                    command.DefaultCompressionLevel = this.DefaultCompressionLevel;
+                    command.Output = output;
+                    command.Messaging = this.Messaging;
+                    command.BackendExtensions = this.BackendExtensions;
+                    command.LayoutDirectory = layoutDirectory;
+                    command.Compressed = compressed;
+                    command.FileRowsByCabinet = filesByCabinetMedia;
+                    command.ResolveMedia = this.ResolveMedia;
+                    command.TableDefinitions = tableDefinitions;
+                    command.TempFilesLocation = this.IntermediateFolder;
+                    command.Execute();
 
-#if TODO_FINISH_PATCH
-            if (OutputType.Patch == this.Output.Type)
-            {
-                // copy output data back into the transforms
-                this.CopyToTransformData(this.Output);
-            }
-#endif
+                    fileTransfers.AddRange(command.FileTransfers);
+                    trackedFiles.AddRange(command.TrackedFiles);
+                }
 
-            this.ValidateComponentGuids(output);
+#if DELETE
+                if (OutputType.Patch == output.Type)
+                {
+                    // Copy output data back into the transforms.
+#if TODO_PATCHING
+                    var command = new CopyTransformDataCommand(this.Messaging, output, tableDefinitions, copyOutFileRows: false);
+                    command.Execute();
 
-            // stop processing if an error previously occurred
-            if (this.Messaging.EncounteredError)
-            {
-                return;
-            }
+                    this.CopyToTransformData(this.Output);
+#endif
+                }
+#endif
 
-            // Generate database file.
-            this.Messaging.Write(VerboseMessages.GeneratingDatabase());
+                // stop processing if an error previously occurred
+                if (this.Messaging.EncounteredError)
+                {
+                    return;
+                }
 
-            {
-                var trackMsi = this.BackendHelper.TrackFile(this.OutputPath, TrackedFileType.Final);
-                trackedFiles.Add(trackMsi);
+                // Generate database file.
+                this.Messaging.Write(VerboseMessages.GeneratingDatabase());
 
-                var temporaryFiles = this.GenerateDatabase(output, tableDefinitions, trackMsi.Path, false, false);
-                trackedFiles.AddRange(temporaryFiles);
-            }
+                {
+                    var trackMsi = this.BackendHelper.TrackFile(this.OutputPath, TrackedFileType.Final);
+                    trackedFiles.Add(trackMsi);
 
-            // Stop processing if an error previously occurred.
-            if (this.Messaging.EncounteredError)
-            {
-                return;
-            }
+                    var temporaryFiles = this.GenerateDatabase(output, tableDefinitions, trackMsi.Path, false, false);
+                    trackedFiles.AddRange(temporaryFiles);
+                }
 
-            // Merge modules.
-            if (containsMergeModules)
-            {
-                this.Messaging.Write(VerboseMessages.MergingModules());
+                // Stop processing if an error previously occurred.
+                if (this.Messaging.EncounteredError)
+                {
+                    return;
+                }
 
-                // Add back possibly suppressed sequence tables since all sequence tables must be present
-                // for the merge process to work. We'll drop the suppressed sequence tables again as
-                // necessary.
-                foreach (SequenceTable sequence in Enum.GetValues(typeof(SequenceTable)))
+                // Merge modules.
+                if (containsMergeModules)
                 {
-                    var sequenceTableName = sequence.ToString();
-                    var sequenceTable = output.Tables[sequenceTableName];
+                    this.Messaging.Write(VerboseMessages.MergingModules());
 
-                    if (null == sequenceTable)
+                    // Add back possibly suppressed sequence tables since all sequence tables must be present
+                    // for the merge process to work. We'll drop the suppressed sequence tables again as
+                    // necessary.
+                    foreach (SequenceTable sequence in Enum.GetValues(typeof(SequenceTable)))
                     {
-                        sequenceTable = output.EnsureTable(tableDefinitions[sequenceTableName]);
-                    }
+                        var sequenceTableName = sequence.ToString();
+                        var sequenceTable = output.Tables[sequenceTableName];
 
-                    if (0 == sequenceTable.Rows.Count)
-                    {
-                        suppressedTableNames.Add(sequenceTableName);
+                        if (null == sequenceTable)
+                        {
+                            sequenceTable = output.EnsureTable(tableDefinitions[sequenceTableName]);
+                        }
+
+                        if (0 == sequenceTable.Rows.Count)
+                        {
+                            suppressedTableNames.Add(sequenceTableName);
+                        }
                     }
-                }
 
-                var command = new MergeModulesCommand();
-                command.FileFacades = fileFacades;
-                command.Output = output;
-                command.OutputPath = this.OutputPath;
-                command.SuppressedTableNames = suppressedTableNames;
-                command.Execute();
-            }
+                    var command = new MergeModulesCommand();
+                    command.FileFacades = fileFacades;
+                    command.Output = output;
+                    command.OutputPath = this.OutputPath;
+                    command.SuppressedTableNames = suppressedTableNames;
+                    command.Execute();
+                }
 
-            if (this.Messaging.EncounteredError)
-            {
-                return;
-            }
+                if (this.Messaging.EncounteredError)
+                {
+                    return;
+                }
 
 #if TODO_FINISH_VALIDATION
             // Validate the output if there is an MSI validator.
@@ -519,27 +554,29 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             }
 #endif
 
-            // Process uncompressed files.
-            if (!this.Messaging.EncounteredError && !this.SuppressLayout && uncompressedFiles.Any())
-            {
-                var command = new ProcessUncompressedFilesCommand(section, this.BackendHelper, this.PathResolver);
-                command.Compressed = compressed;
-                command.FileFacades = uncompressedFiles;
-                command.LayoutDirectory = layoutDirectory;
-                command.LongNamesInImage = longNames;
-                command.ResolveMedia = this.ResolveMedia;
-                command.DatabasePath = this.OutputPath;
-                command.Execute();
+                // Process uncompressed files.
+                if (!this.Messaging.EncounteredError && !this.SuppressLayout && uncompressedFiles.Any())
+                {
+                    var command = new ProcessUncompressedFilesCommand(section, this.BackendHelper, this.PathResolver);
+                    command.Compressed = compressed;
+                    command.FileFacades = uncompressedFiles;
+                    command.LayoutDirectory = layoutDirectory;
+                    command.LongNamesInImage = longNames;
+                    command.ResolveMedia = this.ResolveMedia;
+                    command.DatabasePath = this.OutputPath;
+                    command.Execute();
 
-                fileTransfers.AddRange(command.FileTransfers);
-                trackedFiles.AddRange(command.TrackedFiles);
+                    fileTransfers.AddRange(command.FileTransfers);
+                    trackedFiles.AddRange(command.TrackedFiles);
+                }
+
+                // TODO: this is not sufficient to collect all Input files (for example, it misses Binary and Icon tables).
+                trackedFiles.AddRange(fileFacades.Select(f => this.BackendHelper.TrackFile(f.SourcePath, TrackedFileType.Input, f.SourceLineNumber)));
             }
 
             this.Wixout = this.CreateWixout(trackedFiles, this.Intermediate, output);
 
             this.FileTransfers = fileTransfers;
-            // TODO: this is not sufficient to collect all Input files (for example, it misses Binary and Icon tables).
-            trackedFiles.AddRange(fileFacades.Select(f => this.BackendHelper.TrackFile(f.File.Source.Path, TrackedFileType.Input, f.File.SourceLineNumbers)));
             this.TrackedFiles = trackedFiles;
         }
 
@@ -566,7 +603,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             return wixout;
         }
 
-#if TODO_FINISH_PATCH
+#if TODO_PATCHING
         /// <summary>
         /// Copy file data between transform substorages and the patch output object
         /// </summary>
@@ -936,28 +973,15 @@ namespace WixToolset.Core.WindowsInstaller.Bind
         /// <param name="useSubdirectory">Whether to use a subdirectory based on the <paramref name="databaseFile"/> file name for intermediate files.</param>
         private IEnumerable<ITrackedFile> GenerateDatabase(WindowsInstallerData output, TableDefinitionCollection tableDefinitions, string databaseFile, bool keepAddedColumns, bool useSubdirectory)
         {
-            var command = new GenerateDatabaseCommand();
-            command.BackendHelper = this.BackendHelper;
-            command.Extensions = this.FileSystemExtensions;
-            command.Output = output;
-            command.OutputPath = databaseFile;
-            command.KeepAddedColumns = keepAddedColumns;
-            command.UseSubDirectory = useSubdirectory;
-            command.SuppressAddingValidationRows = this.SuppressAddingValidationRows;
-            command.TableDefinitions = tableDefinitions;
-            command.IntermediateFolder = this.IntermediateFolder;
-            command.Codepage = this.Codepage;
+            var command = new GenerateDatabaseCommand(this.Messaging, this.BackendHelper, this.FileSystemExtensions, output, databaseFile, tableDefinitions, this.IntermediateFolder, this.Codepage, keepAddedColumns, this.SuppressAddingValidationRows, useSubdirectory);
             command.Execute();
 
             return command.GeneratedTemporaryFiles;
         }
 
-        #region IDisposable Support
+#region IDisposable Support
 
-        public void Dispose()
-        {
-            this.Dispose(true);
-        }
+        public void Dispose() => this.Dispose(true);
 
         protected virtual void Dispose(bool disposing)
         {
@@ -972,6 +996,6 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             }
         }
 
-        #endregion
+#endregion
     }
 }
diff --git a/src/WixToolset.Core.WindowsInstaller/Bind/BindTransformCommand.cs b/src/WixToolset.Core.WindowsInstaller/Bind/BindTransformCommand.cs
index 8757024e..ea6e4f31 100644
--- a/src/WixToolset.Core.WindowsInstaller/Bind/BindTransformCommand.cs
+++ b/src/WixToolset.Core.WindowsInstaller/Bind/BindTransformCommand.cs
@@ -15,24 +15,37 @@ namespace WixToolset.Core.WindowsInstaller.Bind
 
     internal class BindTransformCommand
     {
-        public IEnumerable<IFileSystemExtension> Extensions { private get; set; }
+        public BindTransformCommand(IMessaging messaging, IBackendHelper backendHelper, IEnumerable<IFileSystemExtension> extensions, string intermediateFolder, WindowsInstallerData transform, string outputPath, TableDefinitionCollection tableDefinitions)
+        {
+            this.Messaging = messaging;
+            this.BackendHelper = backendHelper;
+            this.Extensions = extensions;
+            this.IntermediateFolder = intermediateFolder;
+            this.Transform = transform;
+            this.OutputPath = outputPath;
+            this.TableDefinitions = tableDefinitions;
+        }
+
+        private IMessaging Messaging { get; }
 
-        public TableDefinitionCollection TableDefinitions { private get; set; }
+        private IBackendHelper BackendHelper { get; }
 
-        public string TempFilesLocation { private get; set; }
+        private IEnumerable<IFileSystemExtension> Extensions { get; }
 
-        public WindowsInstallerData Transform { private get; set; }
+        private TableDefinitionCollection TableDefinitions { get; }
 
-        public IMessaging Messaging { private get; set; }
+        private string IntermediateFolder { get; }
 
-        public string OutputPath { private get; set; }
+        private WindowsInstallerData Transform { get; }
+
+        private string OutputPath { get; }
 
         public void Execute()
         {
-            int transformFlags = 0;
+            var transformFlags = 0;
 
-            WindowsInstallerData targetOutput = new WindowsInstallerData(null);
-            WindowsInstallerData updatedOutput = new WindowsInstallerData(null);
+            var targetOutput = new WindowsInstallerData(null);
+            var updatedOutput = new WindowsInstallerData(null);
 
             // TODO: handle added columns
 
@@ -49,8 +62,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             string targetUpgradeCode = null;
             string updatedUpgradeCode = null;
 
-            Table propertyTable = this.Transform.Tables["Property"];
-            if (null != propertyTable)
+            if (this.Transform.TryGetTable("Property", out var propertyTable))
             {
                 for (int i = propertyTable.Rows.Count - 1; i >= 0; i--)
                 {
@@ -68,18 +80,21 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                 }
             }
 
-            Table targetSummaryInfo = targetOutput.EnsureTable(this.TableDefinitions["_SummaryInformation"]);
-            Table updatedSummaryInfo = updatedOutput.EnsureTable(this.TableDefinitions["_SummaryInformation"]);
-            Table targetPropertyTable = targetOutput.EnsureTable(this.TableDefinitions["Property"]);
-            Table updatedPropertyTable = updatedOutput.EnsureTable(this.TableDefinitions["Property"]);
+            var targetSummaryInfo = targetOutput.EnsureTable(this.TableDefinitions["_SummaryInformation"]);
+            var updatedSummaryInfo = updatedOutput.EnsureTable(this.TableDefinitions["_SummaryInformation"]);
+            var targetPropertyTable = targetOutput.EnsureTable(this.TableDefinitions["Property"]);
+            var updatedPropertyTable = updatedOutput.EnsureTable(this.TableDefinitions["Property"]);
 
             // process special summary information values
-            foreach (Row row in this.Transform.Tables["_SummaryInformation"].Rows)
+            foreach (var row in this.Transform.Tables["_SummaryInformation"].Rows)
             {
-                if ((int)SummaryInformation.Transform.CodePage == (int)row[0])
+                var summaryId = row.FieldAsInteger(0);
+                var summaryData = row.FieldAsString(1);
+
+                if ((int)SummaryInformation.Transform.CodePage == summaryId)
                 {
                     // convert from a web name if provided
-                    string codePage = (string)row.Fields[1].Data;
+                    var codePage = summaryData;
                     if (null == codePage)
                     {
                         codePage = "0";
@@ -89,7 +104,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                         codePage = Common.GetValidCodePage(codePage).ToString(CultureInfo.InvariantCulture);
                     }
 
-                    string previousCodePage = (string)row.Fields[1].PreviousData;
+                    var previousCodePage = row.Fields[1].PreviousData;
                     if (null == previousCodePage)
                     {
                         previousCodePage = "0";
@@ -99,50 +114,50 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                         previousCodePage = Common.GetValidCodePage(previousCodePage).ToString(CultureInfo.InvariantCulture);
                     }
 
-                    Row targetCodePageRow = targetSummaryInfo.CreateRow(null);
+                    var targetCodePageRow = targetSummaryInfo.CreateRow(null);
                     targetCodePageRow[0] = 1; // PID_CODEPAGE
                     targetCodePageRow[1] = previousCodePage;
 
-                    Row updatedCodePageRow = updatedSummaryInfo.CreateRow(null);
+                    var updatedCodePageRow = updatedSummaryInfo.CreateRow(null);
                     updatedCodePageRow[0] = 1; // PID_CODEPAGE
                     updatedCodePageRow[1] = codePage;
                 }
-                else if ((int)SummaryInformation.Transform.TargetPlatformAndLanguage == (int)row[0] ||
-                         (int)SummaryInformation.Transform.UpdatedPlatformAndLanguage == (int)row[0])
+                else if ((int)SummaryInformation.Transform.TargetPlatformAndLanguage == summaryId ||
+                         (int)SummaryInformation.Transform.UpdatedPlatformAndLanguage == summaryId)
                 {
                     // the target language
-                    string[] propertyData = ((string)row[1]).Split(';');
-                    string lang = 2 == propertyData.Length ? propertyData[1] : "0";
+                    var propertyData = summaryData.Split(';');
+                    var lang = 2 == propertyData.Length ? propertyData[1] : "0";
 
-                    Table tempSummaryInfo = (int)SummaryInformation.Transform.TargetPlatformAndLanguage == (int)row[0] ? targetSummaryInfo : updatedSummaryInfo;
-                    Table tempPropertyTable = (int)SummaryInformation.Transform.TargetPlatformAndLanguage == (int)row[0] ? targetPropertyTable : updatedPropertyTable;
+                    var tempSummaryInfo = (int)SummaryInformation.Transform.TargetPlatformAndLanguage == summaryId ? targetSummaryInfo : updatedSummaryInfo;
+                    var tempPropertyTable = (int)SummaryInformation.Transform.TargetPlatformAndLanguage == summaryId ? targetPropertyTable : updatedPropertyTable;
 
-                    Row productLanguageRow = tempPropertyTable.CreateRow(null);
+                    var productLanguageRow = tempPropertyTable.CreateRow(null);
                     productLanguageRow[0] = "ProductLanguage";
                     productLanguageRow[1] = lang;
 
                     // set the platform;language on the MSI to be generated
-                    Row templateRow = tempSummaryInfo.CreateRow(null);
+                    var templateRow = tempSummaryInfo.CreateRow(null);
                     templateRow[0] = 7; // PID_TEMPLATE
-                    templateRow[1] = (string)row[1];
+                    templateRow[1] = summaryData;
                 }
-                else if ((int)SummaryInformation.Transform.ProductCodes == (int)row[0])
+                else if ((int)SummaryInformation.Transform.ProductCodes == summaryId)
                 {
-                    string[] propertyData = ((string)row[1]).Split(';');
+                    var propertyData = summaryData.Split(';');
 
-                    Row targetProductCodeRow = targetPropertyTable.CreateRow(null);
+                    var targetProductCodeRow = targetPropertyTable.CreateRow(null);
                     targetProductCodeRow[0] = "ProductCode";
                     targetProductCodeRow[1] = propertyData[0].Substring(0, 38);
 
-                    Row targetProductVersionRow = targetPropertyTable.CreateRow(null);
+                    var targetProductVersionRow = targetPropertyTable.CreateRow(null);
                     targetProductVersionRow[0] = "ProductVersion";
                     targetProductVersionRow[1] = propertyData[0].Substring(38);
 
-                    Row updatedProductCodeRow = updatedPropertyTable.CreateRow(null);
+                    var updatedProductCodeRow = updatedPropertyTable.CreateRow(null);
                     updatedProductCodeRow[0] = "ProductCode";
                     updatedProductCodeRow[1] = propertyData[1].Substring(0, 38);
 
-                    Row updatedProductVersionRow = updatedPropertyTable.CreateRow(null);
+                    var updatedProductVersionRow = updatedPropertyTable.CreateRow(null);
                     updatedProductVersionRow[0] = "ProductVersion";
                     updatedProductVersionRow[1] = propertyData[1].Substring(38);
 
@@ -153,7 +168,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                     targetUpgradeCode = propertyData[2];
                     if (!String.IsNullOrEmpty(targetUpgradeCode))
                     {
-                        Row targetUpgradeCodeRow = targetPropertyTable.CreateRow(null);
+                        var targetUpgradeCodeRow = targetPropertyTable.CreateRow(null);
                         targetUpgradeCodeRow[0] = "UpgradeCode";
                         targetUpgradeCodeRow[1] = targetUpgradeCode;
 
@@ -167,16 +182,16 @@ namespace WixToolset.Core.WindowsInstaller.Bind
 
                     if (!String.IsNullOrEmpty(updatedUpgradeCode))
                     {
-                        Row updatedUpgradeCodeRow = updatedPropertyTable.CreateRow(null);
+                        var updatedUpgradeCodeRow = updatedPropertyTable.CreateRow(null);
                         updatedUpgradeCodeRow[0] = "UpgradeCode";
                         updatedUpgradeCodeRow[1] = updatedUpgradeCode;
                     }
                 }
-                else if ((int)SummaryInformation.Transform.ValidationFlags == (int)row[0])
+                else if ((int)SummaryInformation.Transform.ValidationFlags == summaryId)
                 {
-                    transformFlags = Convert.ToInt32(row[1], CultureInfo.InvariantCulture);
+                    transformFlags = Convert.ToInt32(summaryData, CultureInfo.InvariantCulture);
                 }
-                else if ((int)SummaryInformation.Transform.Reserved11 == (int)row[0])
+                else if ((int)SummaryInformation.Transform.Reserved11 == summaryId)
                 {
                     // PID_LASTPRINTED should be null for transforms
                     row.Operation = RowOperation.None;
@@ -184,11 +199,11 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                 else
                 {
                     // add everything else as is
-                    Row targetRow = targetSummaryInfo.CreateRow(null);
+                    var targetRow = targetSummaryInfo.CreateRow(null);
                     targetRow[0] = row[0];
                     targetRow[1] = row[1];
 
-                    Row updatedRow = updatedSummaryInfo.CreateRow(null);
+                    var updatedRow = updatedSummaryInfo.CreateRow(null);
                     updatedRow[0] = row[0];
                     updatedRow[1] = row[1];
                 }
@@ -205,7 +220,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
 
             string emptyFile = null;
 
-            foreach (Table table in this.Transform.Tables)
+            foreach (var table in this.Transform.Tables)
             {
                 // Ignore unreal tables when building transforms except the _Stream table.
                 // These tables are ignored when generating the database so there is no reason
@@ -231,20 +246,21 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                 }
 
                 // process row operations
-                foreach (Row row in table.Rows)
+                foreach (var row in table.Rows)
                 {
                     switch (row.Operation)
                     {
                         case RowOperation.Add:
-                            Table updatedTable = updatedOutput.EnsureTable(table.Definition);
+                            var updatedTable = updatedOutput.EnsureTable(table.Definition);
                             updatedTable.Rows.Add(row);
                             continue;
+
                         case RowOperation.Delete:
-                            Table targetTable = targetOutput.EnsureTable(table.Definition);
+                            var targetTable = targetOutput.EnsureTable(table.Definition);
                             targetTable.Rows.Add(row);
 
                             // fill-in non-primary key values
-                            foreach (Field field in row.Fields)
+                            foreach (var field in row.Fields)
                             {
                                 if (!field.Column.PrimaryKey)
                                 {
@@ -256,7 +272,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                                     {
                                         if (null == emptyFile)
                                         {
-                                            emptyFile = Path.Combine(this.TempFilesLocation, "empty");
+                                            emptyFile = Path.Combine(this.IntermediateFolder, "empty");
                                         }
 
                                         field.Data = emptyFile;
@@ -273,7 +289,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                     // Assure that the file table's sequence is populated
                     if ("File" == table.Name)
                     {
-                        foreach (Row fileRow in table.Rows)
+                        foreach (var fileRow in table.Rows)
                         {
                             if (null == fileRow[7])
                             {
@@ -290,60 +306,48 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                     }
 
                     // process modified and unmodified rows
-                    bool modifiedRow = false;
-                    Row targetRow = new Row(null, table.Definition);
-                    Row updatedRow = row;
-                    for (int i = 0; i < row.Fields.Length; i++)
+                    var modifiedRow = false;
+                    var targetRow = new Row(null, table.Definition);
+                    var updatedRow = row;
+                    for (var i = 0; i < row.Fields.Length; i++)
                     {
-                        Field updatedField = row.Fields[i];
+                        var updatedField = row.Fields[i];
 
                         if (updatedField.Modified)
                         {
                             // set a different value in the target row to ensure this value will be modified during transform generation
                             if (ColumnType.Number == updatedField.Column.Type && !updatedField.Column.IsLocalizable)
                             {
-                                if (null == updatedField.Data || 1 != (int)updatedField.Data)
-                                {
-                                    targetRow[i] = 1;
-                                }
-                                else
-                                {
-                                    targetRow[i] = 2;
-                                }
+                                var data = updatedField.AsNullableInteger();
+                                targetRow[i] = (data == 1) ? 2 : 1;
                             }
                             else if (ColumnType.Object == updatedField.Column.Type)
                             {
                                 if (null == emptyFile)
                                 {
-                                    emptyFile = Path.Combine(this.TempFilesLocation, "empty");
+                                    emptyFile = Path.Combine(this.IntermediateFolder, "empty");
                                 }
 
                                 targetRow[i] = emptyFile;
                             }
                             else
                             {
-                                if ("0" != (string)updatedField.Data)
-                                {
-                                    targetRow[i] = "0";
-                                }
-                                else
-                                {
-                                    targetRow[i] = "1";
-                                }
+                                var data = updatedField.AsString();
+                                targetRow[i] = (data == "0") ? "1" : "0";
                             }
 
                             modifiedRow = true;
                         }
                         else if (ColumnType.Object == updatedField.Column.Type)
                         {
-                            ObjectField objectField = (ObjectField)updatedField;
+                            var objectField = (ObjectField)updatedField;
 
                             // create an empty file for comparing against
                             if (null == objectField.PreviousData)
                             {
                                 if (null == emptyFile)
                                 {
-                                    emptyFile = Path.Combine(this.TempFilesLocation, "empty");
+                                    emptyFile = Path.Combine(this.IntermediateFolder, "empty");
                                 }
 
                                 targetRow[i] = emptyFile;
@@ -372,10 +376,10 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                             "ProductVersion" == (string)row[0] ||
                             "UpgradeCode" == (string)row[0])))
                     {
-                        Table targetTable = targetOutput.EnsureTable(table.Definition);
+                        var targetTable = targetOutput.EnsureTable(table.Definition);
                         targetTable.Rows.Add(targetRow);
 
-                        Table updatedTable = updatedOutput.EnsureTable(table.Definition);
+                        var updatedTable = updatedOutput.EnsureTable(table.Definition);
                         updatedTable.Rows.Add(updatedRow);
                     }
                 }
@@ -392,38 +396,36 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                 return;
             }
 
-            string transformFileName = Path.GetFileNameWithoutExtension(this.OutputPath);
-            string targetDatabaseFile = Path.Combine(this.TempFilesLocation, String.Concat(transformFileName, "_target.msi"));
-            string updatedDatabaseFile = Path.Combine(this.TempFilesLocation, String.Concat(transformFileName, "_updated.msi"));
+            var transformFileName = Path.GetFileNameWithoutExtension(this.OutputPath);
+            var targetDatabaseFile = Path.Combine(this.IntermediateFolder, String.Concat(transformFileName, "_target.msi"));
+            var updatedDatabaseFile = Path.Combine(this.IntermediateFolder, String.Concat(transformFileName, "_updated.msi"));
 
             try
             {
                 if (!String.IsNullOrEmpty(emptyFile))
                 {
-                    using (FileStream fileStream = File.Create(emptyFile))
+                    using (var fileStream = File.Create(emptyFile))
                     {
                     }
                 }
 
-                this.GenerateDatabase(targetOutput, targetDatabaseFile, false);
-                this.GenerateDatabase(updatedOutput, updatedDatabaseFile, true);
+                this.GenerateDatabase(targetOutput, targetDatabaseFile, keepAddedColumns: false);
+                this.GenerateDatabase(updatedOutput, updatedDatabaseFile, keepAddedColumns: true);
 
                 // make sure the directory exists
                 Directory.CreateDirectory(Path.GetDirectoryName(this.OutputPath));
 
                 // create the transform file
-                using (Database targetDatabase = new Database(targetDatabaseFile, OpenDatabase.ReadOnly))
+                using (var targetDatabase = new Database(targetDatabaseFile, OpenDatabase.ReadOnly))
+                using (var updatedDatabase = new Database(updatedDatabaseFile, OpenDatabase.ReadOnly))
                 {
-                    using (Database updatedDatabase = new Database(updatedDatabaseFile, OpenDatabase.ReadOnly))
+                    if (updatedDatabase.GenerateTransform(targetDatabase, this.OutputPath))
                     {
-                        if (updatedDatabase.GenerateTransform(targetDatabase, this.OutputPath))
-                        {
-                            updatedDatabase.CreateTransformSummaryInfo(targetDatabase, this.OutputPath, (TransformErrorConditions)(transformFlags & 0xFFFF), (TransformValidations)((transformFlags >> 16) & 0xFFFF));
-                        }
-                        else
-                        {
-                            this.Messaging.Write(ErrorMessages.NoDifferencesInTransform(this.Transform.SourceLineNumbers));
-                        }
+                        updatedDatabase.CreateTransformSummaryInfo(targetDatabase, this.OutputPath, (TransformErrorConditions)(transformFlags & 0xFFFF), (TransformValidations)((transformFlags >> 16) & 0xFFFF));
+                    }
+                    else
+                    {
+                        this.Messaging.Write(ErrorMessages.NoDifferencesInTransform(this.Transform.SourceLineNumbers));
                     }
                 }
             }
@@ -458,16 +460,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
 
         private void GenerateDatabase(WindowsInstallerData output, string outputPath, bool keepAddedColumns)
         {
-            var command = new GenerateDatabaseCommand();
-            command.Codepage = output.Codepage;
-            command.Extensions = this.Extensions;
-            command.KeepAddedColumns = keepAddedColumns;
-            command.Output = output;
-            command.OutputPath = outputPath;
-            command.TableDefinitions = this.TableDefinitions;
-            command.IntermediateFolder = this.TempFilesLocation;
-            command.SuppressAddingValidationRows = true;
-            command.UseSubDirectory = true;
+            var command = new GenerateDatabaseCommand(this.Messaging, this.BackendHelper, this.Extensions, output, outputPath, this.TableDefinitions, this.IntermediateFolder, codepage: -1, keepAddedColumns, suppressAddingValidationRows: true, useSubdirectory: true );
             command.Execute();
         }
     }
diff --git a/src/WixToolset.Core.WindowsInstaller/Bind/CabinetBuilder.cs b/src/WixToolset.Core.WindowsInstaller/Bind/CabinetBuilder.cs
index bf1140d8..ec4e0818 100644
--- a/src/WixToolset.Core.WindowsInstaller/Bind/CabinetBuilder.cs
+++ b/src/WixToolset.Core.WindowsInstaller/Bind/CabinetBuilder.cs
@@ -152,7 +152,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
 
                     foreach (FileFacade facade in cabinetWorkItem.FileFacades) // No other easy way than looping to get the only row
                     {
-                        if ((ulong)facade.File.FileSize >= maxPreCompressedSizeInBytes)
+                        if ((ulong)facade.FileSize >= maxPreCompressedSizeInBytes)
                         {
                             // If file is larger than MaximumUncompressedFileSize set Maximum Cabinet Size for Cabinet Splitting
                             maxCabinetSize = this.MaximumCabinetSizeForLargeFileSplitting;
@@ -166,8 +166,8 @@ namespace WixToolset.Core.WindowsInstaller.Bind
 
             var files = cabinetWorkItem.FileFacades
                 .Select(facade => facade.Hash == null ?
-                    new CabinetCompressFile(facade.File.Source.Path, facade.File.Id.Id) :
-                    new CabinetCompressFile(facade.File.Source.Path, facade.File.Id.Id, facade.Hash.HashPart1, facade.Hash.HashPart2, facade.Hash.HashPart3, facade.Hash.HashPart4))
+                    new CabinetCompressFile(facade.SourcePath, facade.Id) :
+                    new CabinetCompressFile(facade.SourcePath, facade.Id, facade.Hash.HashPart1, facade.Hash.HashPart2, facade.Hash.HashPart3, facade.Hash.HashPart4))
                 .ToList();
 
             var cab = new Cabinet(cabinetPath);
diff --git a/src/WixToolset.Core.WindowsInstaller/Bind/CabinetResolver.cs b/src/WixToolset.Core.WindowsInstaller/Bind/CabinetResolver.cs
index 3fa3f3a0..79b1c619 100644
--- a/src/WixToolset.Core.WindowsInstaller/Bind/CabinetResolver.cs
+++ b/src/WixToolset.Core.WindowsInstaller/Bind/CabinetResolver.cs
@@ -112,8 +112,8 @@ namespace WixToolset.Core.WindowsInstaller.Bind
         private IBindFileWithPath CreateBindFileWithPath(FileFacade facade)
         {
             var result = this.ServiceProvider.GetService<IBindFileWithPath>();
-            result.Id = facade.File.Id.Id;
-            result.Path = facade.File.Source.Path;
+            result.Id = facade.Id;
+            result.Path = facade.SourcePath;
 
             return result;
         }
diff --git a/src/WixToolset.Core.WindowsInstaller/Bind/CopyTransformDataCommand.cs b/src/WixToolset.Core.WindowsInstaller/Bind/CopyTransformDataCommand.cs
index 107f3208..0dcce61b 100644
--- a/src/WixToolset.Core.WindowsInstaller/Bind/CopyTransformDataCommand.cs
+++ b/src/WixToolset.Core.WindowsInstaller/Bind/CopyTransformDataCommand.cs
@@ -1,12 +1,15 @@
 // 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 DELETE
+
 namespace WixToolset.Core.WindowsInstaller.Bind
 {
     using System;
     using System.Collections.Generic;
     using System.Diagnostics;
+    using System.IO;
+    using System.Linq;
     using WixToolset.Core.Bind;
-    using WixToolset.Core.Native;
     using WixToolset.Data;
     using WixToolset.Data.Tuples;
     using WixToolset.Data.WindowsInstaller;
@@ -16,15 +19,23 @@ namespace WixToolset.Core.WindowsInstaller.Bind
 
     internal class CopyTransformDataCommand
     {
-        public bool CopyOutFileRows { private get; set; }
+        public CopyTransformDataCommand(IMessaging messaging, WindowsInstallerData output, TableDefinitionCollection tableDefinitions, bool copyOutFileRows)
+        {
+            this.Messaging = messaging;
+            this.Output = output;
+            this.TableDefinitions = tableDefinitions;
+            this.CopyOutFileRows = copyOutFileRows;
+        }
 
-        public IEnumerable<IFileSystemExtension> Extensions { private get; set; }
+        private bool CopyOutFileRows { get; }
 
-        public IMessaging Messaging { private get; set; }
+        public IEnumerable<IFileSystemExtension> Extensions { get; }
 
-        public WindowsInstallerData Output { private get; set; }
+        private IMessaging Messaging { get; }
 
-        public TableDefinitionCollection TableDefinitions { private get; set; }
+        private WindowsInstallerData Output { get; }
+
+        private TableDefinitionCollection TableDefinitions { get; }
 
         public IEnumerable<FileFacade> FileFacades { get; private set; }
 
@@ -32,18 +43,17 @@ namespace WixToolset.Core.WindowsInstaller.Bind
         {
             Debug.Assert(OutputType.Patch != this.Output.Type);
 
-            List<FileFacade> allFileRows = this.CopyOutFileRows ? new List<FileFacade>() : null;
+            var allFileRows = this.CopyOutFileRows ? new List<FileFacade>() : null;
 
-#if REVISIT_FOR_PATCHING // TODO: Fix this patching related code to work correctly with FileFacades.
-            bool copyToPatch = (allFileRows != null);
-            bool copyFromPatch = !copyToPatch;
+            var copyToPatch = (allFileRows != null);
+            var copyFromPatch = !copyToPatch;
 
-            RowDictionary<MediaRow> patchMediaRows = new RowDictionary<MediaRow>();
+            var patchMediaRows = new RowDictionary<MediaRow>();
 
-            Dictionary<int, RowDictionary<WixFileRow>> patchMediaFileRows = new Dictionary<int, RowDictionary<WixFileRow>>();
+            var patchMediaFileRows = new Dictionary<int, RowDictionary<WixFileRow>>();
 
-            Table patchActualFileTable = this.Output.EnsureTable(this.TableDefinitions["File"]);
-            Table patchFileTable = this.Output.EnsureTable(this.TableDefinitions["WixFile"]);
+            var patchActualFileTable = this.Output.EnsureTable(this.TableDefinitions["File"]);
+            var patchFileTable = this.Output.EnsureTable(this.TableDefinitions["WixFile"]);
 
             if (copyFromPatch)
             {
@@ -51,8 +61,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                 foreach (WixFileRow patchFileRow in patchFileTable.Rows)
                 {
                     int diskId = patchFileRow.DiskId;
-                    RowDictionary<WixFileRow> mediaFileRows;
-                    if (!patchMediaFileRows.TryGetValue(diskId, out mediaFileRows))
+                    if (!patchMediaFileRows.TryGetValue(diskId, out var mediaFileRows))
                     {
                         mediaFileRows = new RowDictionary<WixFileRow>();
                         patchMediaFileRows.Add(diskId, mediaFileRows);
@@ -61,24 +70,25 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                     mediaFileRows.Add(patchFileRow);
                 }
 
-                Table patchMediaTable = this.Output.EnsureTable(this.TableDefinitions["Media"]);
+                var patchMediaTable = this.Output.EnsureTable(this.TableDefinitions["Media"]);
                 patchMediaRows = new RowDictionary<MediaRow>(patchMediaTable);
             }
 
-            // index paired transforms
-            Dictionary<string, Output> pairedTransforms = new Dictionary<string, Output>();
-            foreach (SubStorage substorage in this.Output.SubStorages)
-            {
-                if (substorage.Name.StartsWith("#"))
-                {
-                    pairedTransforms.Add(substorage.Name.Substring(1), substorage.Data);
-                }
-            }
+            // Index paired transforms by name without the "#" prefix.
+            var pairedTransforms = this.Output.SubStorages.Where(s => s.Name.StartsWith("#")).ToDictionary(s => s.Name.Substring(1), s => s.Data);
+            //Dictionary<string, Output> pairedTransforms = new Dictionary<string, Output>();
+            //foreach (SubStorage substorage in this.Output.SubStorages)
+            //{
+            //    if (substorage.Name.StartsWith("#"))
+            //    {
+            //        pairedTransforms.Add(substorage.Name.Substring(1), substorage.Data);
+            //    }
+            //}
 
             try
             {
-                // copy File bind data into substorages
-                foreach (SubStorage substorage in this.Output.SubStorages)
+                // Copy File bind data into substorages
+                foreach (var substorage in this.Output.SubStorages)
                 {
                     if (substorage.Name.StartsWith("#"))
                     {
@@ -86,25 +96,25 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                         continue;
                     }
 
-                    Output mainTransform = substorage.Data;
-                    Table mainWixFileTable = mainTransform.Tables["WixFile"];
-                    Table mainMsiFileHashTable = mainTransform.Tables["MsiFileHash"];
+                    var mainTransform = substorage.Data;
+                    var mainWixFileTable = mainTransform.Tables["WixFile"];
+                    var mainMsiFileHashTable = mainTransform.Tables["MsiFileHash"];
 
                     this.FileManagerCore.ActiveSubStorage = substorage;
 
-                    RowDictionary<WixFileRow> mainWixFiles = new RowDictionary<WixFileRow>(mainWixFileTable);
-                    RowDictionary<Row> mainMsiFileHashIndex = new RowDictionary<Row>();
+                    var mainWixFiles = new RowDictionary<WixFileRow>(mainWixFileTable);
+                    var mainMsiFileHashIndex = new RowDictionary<Row>();
 
-                    Table mainFileTable = mainTransform.Tables["File"];
-                    Output pairedTransform = (Output)pairedTransforms[substorage.Name];
+                    var mainFileTable = mainTransform.Tables["File"];
+                    var pairedTransform = pairedTransforms[substorage.Name];
 
                     // copy Media.LastSequence and index the MsiFileHash table if it exists.
                     if (copyFromPatch)
                     {
-                        Table pairedMediaTable = pairedTransform.Tables["Media"];
+                        var pairedMediaTable = pairedTransform.Tables["Media"];
                         foreach (MediaRow pairedMediaRow in pairedMediaTable.Rows)
                         {
-                            MediaRow patchMediaRow = patchMediaRows.Get(pairedMediaRow.DiskId);
+                            var patchMediaRow = patchMediaRows.Get(pairedMediaRow.DiskId);
                             pairedMediaRow.Fields[1] = patchMediaRow.Fields[1];
                         }
 
@@ -118,8 +128,8 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                     }
 
                     // Index File table of pairedTransform
-                    Table pairedFileTable = pairedTransform.Tables["File"];
-                    RowDictionary<FileRow> pairedFileRows = new RowDictionary<FileRow>(pairedFileTable);
+                    var pairedFileTable = pairedTransform.Tables["File"];
+                    var pairedFileRows = new RowDictionary<FileRow>(pairedFileTable);
 
                     if (null != mainFileTable)
                     {
@@ -140,12 +150,12 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                                 continue;
                             }
 
-                            WixFileRow mainWixFileRow = mainWixFiles.Get(mainFileRow.File);
+                            var mainWixFileRow = mainWixFiles.Get(mainFileRow.File);
 
                             if (copyToPatch) // when copying to the patch, we need compare the underlying files and include all file changes.
                             {
-                                ObjectField objectField = (ObjectField)mainWixFileRow.Fields[6];
-                                FileRow pairedFileRow = pairedFileRows.Get(mainFileRow.File);
+                                var objectField = (ObjectField)mainWixFileRow.Fields[6];
+                                var pairedFileRow = pairedFileRows.Get(mainFileRow.File);
 
                                 // If the file is new, we always need to add it to the patch.
                                 if (mainFileRow.Operation != RowOperation.Add)
@@ -169,8 +179,8 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                                             if (null != pairedFileRow)
                                             {
                                                 // Always patch-added, but never non-compressed.
-                                                pairedFileRow.Attributes |= MsiInterop.MsidbFileAttributesPatchAdded;
-                                                pairedFileRow.Attributes &= ~MsiInterop.MsidbFileAttributesNoncompressed;
+                                                pairedFileRow.Attributes |= WindowsInstallerConstants.MsidbFileAttributesPatchAdded;
+                                                pairedFileRow.Attributes &= ~WindowsInstallerConstants.MsidbFileAttributesNoncompressed;
                                                 pairedFileRow.Fields[6].Modified = true;
                                                 pairedFileRow.Operation = RowOperation.Modify;
                                             }
@@ -179,14 +189,14 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                                         {
                                             // The File is same. We need mark all the attributes as unchanged.
                                             mainFileRow.Operation = RowOperation.None;
-                                            foreach (Field field in mainFileRow.Fields)
+                                            foreach (var field in mainFileRow.Fields)
                                             {
                                                 field.Modified = false;
                                             }
 
                                             if (null != pairedFileRow)
                                             {
-                                                pairedFileRow.Attributes &= ~MsiInterop.MsidbFileAttributesPatchAdded;
+                                                pairedFileRow.Attributes &= ~WindowsInstallerConstants.MsidbFileAttributesPatchAdded;
                                                 pairedFileRow.Fields[6].Modified = false;
                                                 pairedFileRow.Operation = RowOperation.None;
                                             }
@@ -197,8 +207,8 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                                 else if (null != pairedFileRow) // RowOperation.Add
                                 {
                                     // Always patch-added, but never non-compressed.
-                                    pairedFileRow.Attributes |= MsiInterop.MsidbFileAttributesPatchAdded;
-                                    pairedFileRow.Attributes &= ~MsiInterop.MsidbFileAttributesNoncompressed;
+                                    pairedFileRow.Attributes |= WindowsInstallerConstants.MsidbFileAttributesPatchAdded;
+                                    pairedFileRow.Attributes &= ~WindowsInstallerConstants.MsidbFileAttributesNoncompressed;
                                     pairedFileRow.Fields[6].Modified = true;
                                     pairedFileRow.Operation = RowOperation.Add;
                                 }
@@ -207,20 +217,19 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                             // index patch files by diskId+fileId
                             int diskId = mainWixFileRow.DiskId;
 
-                            RowDictionary<WixFileRow> mediaFileRows;
-                            if (!patchMediaFileRows.TryGetValue(diskId, out mediaFileRows))
+                            if (!patchMediaFileRows.TryGetValue(diskId, out var mediaFileRows))
                             {
                                 mediaFileRows = new RowDictionary<WixFileRow>();
                                 patchMediaFileRows.Add(diskId, mediaFileRows);
                             }
 
-                            string fileId = mainFileRow.File;
-                            WixFileRow patchFileRow = mediaFileRows.Get(fileId);
+                            var fileId = mainFileRow.File;
+                            var patchFileRow = mediaFileRows.Get(fileId);
                             if (copyToPatch)
                             {
                                 if (null == patchFileRow)
                                 {
-                                    FileRow patchActualFileRow = (FileRow)patchFileTable.CreateRow(mainFileRow.SourceLineNumbers);
+                                    var patchActualFileRow = (FileRow)patchFileTable.CreateRow(mainFileRow.SourceLineNumbers);
                                     patchActualFileRow.CopyFrom(mainFileRow);
 
                                     patchFileRow = (WixFileRow)patchFileTable.CreateRow(mainFileRow.SourceLineNumbers);
@@ -237,7 +246,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                                     // make sure Source is same. Otherwise we are silently ignoring a file.
                                     if (0 != String.Compare(patchFileRow.Source, mainWixFileRow.Source, StringComparison.OrdinalIgnoreCase))
                                     {
-                                        Messaging.Instance.OnMessage(WixErrors.SameFileIdDifferentSource(mainFileRow.SourceLineNumbers, fileId, patchFileRow.Source, mainWixFileRow.Source));
+                                        this.Messaging.Write(ErrorMessages.SameFileIdDifferentSource(mainFileRow.SourceLineNumbers, fileId, patchFileRow.Source, mainWixFileRow.Source));
                                     }
 
                                     // capture the previous file versions (and associated data) from this targeted instance of the baseline into the current filerow.
@@ -249,11 +258,11 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                                 // copy data from the patch back to the transform
                                 if (null != patchFileRow)
                                 {
-                                    FileRow pairedFileRow = (FileRow)pairedFileRows.Get(fileId);
-                                    for (int i = 0; i < patchFileRow.Fields.Length; i++)
+                                    var pairedFileRow = pairedFileRows.Get(fileId);
+                                    for (var i = 0; i < patchFileRow.Fields.Length; i++)
                                     {
-                                        string patchValue = patchFileRow[i] == null ? "" : patchFileRow[i].ToString();
-                                        string mainValue = mainFileRow[i] == null ? "" : mainFileRow[i].ToString();
+                                        var patchValue = patchFileRow[i] == null ? String.Empty : patchFileRow.FieldAsString(i);
+                                        var mainValue = mainFileRow[i] == null ? String.Empty : mainFileRow.FieldAsString(i);
 
                                         if (1 == i)
                                         {
@@ -298,17 +307,16 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                                     }
 
                                     // copy MsiFileHash row for this File
-                                    Row patchHashRow;
-                                    if (!mainMsiFileHashIndex.TryGetValue(patchFileRow.File, out patchHashRow))
+                                    if (!mainMsiFileHashIndex.TryGetValue(patchFileRow.File, out var patchHashRow))
                                     {
                                         patchHashRow = patchFileRow.Hash;
                                     }
 
                                     if (null != patchHashRow)
                                     {
-                                        Table mainHashTable = mainTransform.EnsureTable(this.TableDefinitions["MsiFileHash"]);
-                                        Row mainHashRow = mainHashTable.CreateRow(mainFileRow.SourceLineNumbers);
-                                        for (int i = 0; i < patchHashRow.Fields.Length; i++)
+                                        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)
@@ -326,12 +334,12 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                                     List<Row> patchAssemblyNameRows = patchFileRow.AssemblyNames;
                                     if (null != patchAssemblyNameRows)
                                     {
-                                        Table mainAssemblyNameTable = mainTransform.EnsureTable(this.TableDefinitions["MsiAssemblyName"]);
-                                        foreach (Row patchAssemblyNameRow in 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.
-                                            bool foundMatchingModifiedRow = false;
-                                            foreach (Row mainAssemblyNameRow in mainAssemblyNameTable.Rows)
+                                            var foundMatchingModifiedRow = false;
+                                            foreach (var mainAssemblyNameRow in mainAssemblyNameTable.Rows)
                                             {
                                                 if (RowOperation.None != mainAssemblyNameRow.Operation && mainAssemblyNameRow.GetPrimaryKey('/').Equals(patchAssemblyNameRow.GetPrimaryKey('/')))
                                                 {
@@ -342,8 +350,8 @@ namespace WixToolset.Core.WindowsInstaller.Bind
 
                                             if (!foundMatchingModifiedRow)
                                             {
-                                                Row mainAssemblyNameRow = mainAssemblyNameTable.CreateRow(mainFileRow.SourceLineNumbers);
-                                                for (int i = 0; i < patchAssemblyNameRow.Fields.Length; i++)
+                                                var mainAssemblyNameRow = mainAssemblyNameTable.CreateRow(mainFileRow.SourceLineNumbers);
+                                                for (var i = 0; i < patchAssemblyNameRow.Fields.Length; i++)
                                                 {
                                                     mainAssemblyNameRow[i] = patchAssemblyNameRow[i];
                                                 }
@@ -359,34 +367,36 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                                     if (null != patchFileRow.Patch)
                                     {
                                         // Add the PatchFiles action automatically to the AdminExecuteSequence and InstallExecuteSequence tables.
-                                        AddPatchFilesActionToSequenceTable(SequenceTable.AdminExecuteSequence, mainTransform, pairedTransform, mainFileRow);
-                                        AddPatchFilesActionToSequenceTable(SequenceTable.InstallExecuteSequence, mainTransform, pairedTransform, mainFileRow);
+                                        this.AddPatchFilesActionToSequenceTable(SequenceTable.AdminExecuteSequence, mainTransform, pairedTransform, mainFileRow);
+                                        this.AddPatchFilesActionToSequenceTable(SequenceTable.InstallExecuteSequence, mainTransform, pairedTransform, mainFileRow);
 
                                         // Add to Patch table
-                                        Table patchTable = pairedTransform.EnsureTable(this.TableDefinitions["Patch"]);
+                                        var patchTable = pairedTransform.EnsureTable(this.TableDefinitions["Patch"]);
                                         if (0 == patchTable.Rows.Count)
                                         {
                                             patchTable.Operation = TableOperation.Add;
                                         }
 
-                                        Row patchRow = patchTable.CreateRow(mainFileRow.SourceLineNumbers);
+                                        var patchRow = patchTable.CreateRow(mainFileRow.SourceLineNumbers);
                                         patchRow[0] = patchFileRow.File;
                                         patchRow[1] = patchFileRow.Sequence;
 
-                                        FileInfo patchFile = new FileInfo(patchFileRow.Source);
+                                        var patchFile = new FileInfo(patchFileRow.Source);
                                         patchRow[2] = (int)patchFile.Length;
                                         patchRow[3] = 0 == (PatchAttributeType.AllowIgnoreOnError & patchFileRow.PatchAttributes) ? 0 : 1;
 
-                                        string streamName = patchTable.Name + "." + patchRow[0] + "." + patchRow[1];
-                                        if (MsiInterop.MsiMaxStreamNameLength < streamName.Length)
+                                        var streamName = patchTable.Name + "." + patchRow[0] + "." + patchRow[1];
+                                        if (Msi.MsiInterop.MsiMaxStreamNameLength < streamName.Length)
                                         {
                                             streamName = "_" + Guid.NewGuid().ToString("D").ToUpperInvariant().Replace('-', '_');
-                                            Table patchHeadersTable = pairedTransform.EnsureTable(this.TableDefinitions["MsiPatchHeaders"]);
+
+                                            var patchHeadersTable = pairedTransform.EnsureTable(this.TableDefinitions["MsiPatchHeaders"]);
                                             if (0 == patchHeadersTable.Rows.Count)
                                             {
                                                 patchHeadersTable.Operation = TableOperation.Add;
                                             }
-                                            Row patchHeadersRow = patchHeadersTable.CreateRow(mainFileRow.SourceLineNumbers);
+
+                                            var patchHeadersRow = patchHeadersTable.CreateRow(mainFileRow.SourceLineNumbers);
                                             patchHeadersRow[0] = streamName;
                                             patchHeadersRow[1] = patchFileRow.Patch;
                                             patchRow[5] = streamName;
@@ -420,7 +430,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             {
                 this.FileManagerCore.ActiveSubStorage = null;
             }
-#endif
+
             this.FileFacades = allFileRows;
         }
 
@@ -509,17 +519,19 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                 foreach (var row in sequenceTable.Rows)
                 {
                     var actionName = row.FieldAsString(0);
-                    if (String.Equals("PatchFiles", actionName, StringComparison.Ordinal))
-                    {
-                        hasPatchFilesAction = true;
-                    }
-                    else if (String.Equals("InstallFiles", actionName, StringComparison.Ordinal))
+                    switch (actionName)
                     {
-                        installFilesSequence = row.FieldAsInteger(2);
-                    }
-                    else if (String.Equals("DuplicateFiles", actionName, StringComparison.Ordinal))
-                    {
-                        duplicateFilesSequence = row.FieldAsInteger(2);
+                        case "PatchFiles":
+                            hasPatchFilesAction = true;
+                            break;
+
+                        case "InstallFiles":
+                            installFilesSequence = row.FieldAsInteger(2);
+                            break;
+
+                        case "DuplicateFiles":
+                            duplicateFilesSequence = row.FieldAsInteger(2);
+                            break;
                     }
                 }
             }
@@ -531,8 +543,8 @@ namespace WixToolset.Core.WindowsInstaller.Bind
         /// <param name="output">The output to validate.</param>
         private void ValidateFileRowChanges(WindowsInstallerData transform)
         {
-            Table componentTable = transform.Tables["Component"];
-            Table fileTable = transform.Tables["File"];
+            var componentTable = transform.Tables["Component"];
+            var fileTable = transform.Tables["File"];
 
             // There's no sense validating keypaths if the transform has no component or file table
             if (componentTable == null || fileTable == null)
@@ -540,31 +552,31 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                 return;
             }
 
-            Dictionary<string, string> componentKeyPath = new Dictionary<string, string>(componentTable.Rows.Count);
+            var componentKeyPath = new Dictionary<string, string>(componentTable.Rows.Count);
 
             // Index the Component table for non-directory & non-registry key paths.
-            foreach (Row row in componentTable.Rows)
+            foreach (var row in componentTable.Rows)
             {
-                if (null != row.Fields[5].Data &&
-                    0 != ((int)row.Fields[3].Data & WindowsInstallerConstants.MsidbComponentAttributesRegistryKeyPath))
+                var keyPath = row.FieldAsString(5);
+                if (keyPath != null && 0 != (row.FieldAsInteger(3) & WindowsInstallerConstants.MsidbComponentAttributesRegistryKeyPath))
                 {
-                    componentKeyPath.Add(row.Fields[0].Data.ToString(), row.Fields[5].Data.ToString());
+                    componentKeyPath.Add(row.FieldAsString(0), keyPath);
                 }
             }
 
-            Dictionary<string, string> componentWithChangedKeyPath = new Dictionary<string, string>();
-            Dictionary<string, string> componentWithNonKeyPathChanged = new Dictionary<string, string>();
+            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)
             {
-                string fileId = row.Fields[0].Data.ToString();
-                string componentId = row.Fields[1].Data.ToString();
-
                 if (RowOperation.Modify != row.Operation)
                 {
                     continue;
                 }
 
+                var fileId = row.FieldAsString(0);
+                var componentId = row.FieldAsString(1);
+
                 // If this file is the keypath of a component
                 if (componentKeyPath.ContainsValue(fileId))
                 {
@@ -582,12 +594,12 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                 }
             }
 
-            foreach (KeyValuePair<string, string> componentFile in componentWithNonKeyPathChanged)
+            foreach (var componentFile in componentWithNonKeyPathChanged)
             {
                 // Make sure all changes to non keypath files also had a change in the keypath.
-                if (!componentWithChangedKeyPath.ContainsKey(componentFile.Key) && componentKeyPath.ContainsKey(componentFile.Key))
+                if (!componentWithChangedKeyPath.ContainsKey(componentFile.Key) && componentKeyPath.TryGetValue(componentFile.Key, out var keyPath))
                 {
-                    this.Messaging.Write(WarningMessages.UpdateOfNonKeyPathFile((string)componentFile.Value, (string)componentFile.Key, (string)componentKeyPath[componentFile.Key]));
+                    this.Messaging.Write(WarningMessages.UpdateOfNonKeyPathFile(componentFile.Value, componentFile.Key, keyPath));
                 }
             }
         }
@@ -614,3 +626,5 @@ namespace WixToolset.Core.WindowsInstaller.Bind
         }
     }
 }
+
+#endif
diff --git a/src/WixToolset.Core.WindowsInstaller/Bind/CreateDeltaPatchesCommand.cs b/src/WixToolset.Core.WindowsInstaller/Bind/CreateDeltaPatchesCommand.cs
index 19f7b9e5..f5ac00e6 100644
--- a/src/WixToolset.Core.WindowsInstaller/Bind/CreateDeltaPatchesCommand.cs
+++ b/src/WixToolset.Core.WindowsInstaller/Bind/CreateDeltaPatchesCommand.cs
@@ -33,7 +33,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             var optimizePatchSizeForLargeFiles = this.WixPatchId?.OptimizePatchSizeForLargeFiles ?? false;
             var apiPatchingSymbolFlags = (PatchSymbolFlagsType)(this.WixPatchId?.ApiPatchingSymbolFlags ?? 0);
 
-#if REVISIT_FOR_PATCHING
+#if TODO_PATCHING
             foreach (FileFacade facade in this.FileFacades)
             {
                 if (RowOperation.Modify == facade.File.Operation &&
diff --git a/src/WixToolset.Core.WindowsInstaller/Bind/CreateIdtFileCommand.cs b/src/WixToolset.Core.WindowsInstaller/Bind/CreateIdtFileCommand.cs
index 6b1dead5..f09a2e47 100644
--- a/src/WixToolset.Core.WindowsInstaller/Bind/CreateIdtFileCommand.cs
+++ b/src/WixToolset.Core.WindowsInstaller/Bind/CreateIdtFileCommand.cs
@@ -1,4 +1,4 @@
-// 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.
+// 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
 {
@@ -122,13 +122,18 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             tableString.Append(definition.Name);
             foreach (var column in definition.Columns)
             {
-                // conditionally keep columns added in a transform; otherwise,
-                // break because columns can only be added at the end
+                // Conditionally keep columns added in a transform; otherwise,
+                // break because columns can only be added at the end.
                 if (column.Added && !keepAddedColumns)
                 {
                     break;
                 }
 
+                if (column.Unreal)
+                {
+                    continue;
+                }
+
                 if (!first)
                 {
                     columnString.Append('\t');
@@ -168,6 +173,11 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                     break;
                 }
 
+                if (field.Column.Unreal)
+                {
+                    continue;
+                }
+
                 if (first)
                 {
                     first = false;
diff --git a/src/WixToolset.Core.WindowsInstaller/Bind/CreateOutputFromIRCommand.cs b/src/WixToolset.Core.WindowsInstaller/Bind/CreateOutputFromIRCommand.cs
index 31d0b3a6..5707f7ce 100644
--- a/src/WixToolset.Core.WindowsInstaller/Bind/CreateOutputFromIRCommand.cs
+++ b/src/WixToolset.Core.WindowsInstaller/Bind/CreateOutputFromIRCommand.cs
@@ -40,193 +40,193 @@ namespace WixToolset.Core.WindowsInstaller.Bind
 
         public void Execute()
         {
-            var output = new WindowsInstallerData(this.Section.Tuples.First().SourceLineNumbers);
-            output.Codepage = this.Section.Codepage;
-            output.Type = SectionTypeToOutputType(this.Section.Type);
-
-            this.AddSectionToOutput(this.Section, output);
+            this.Output = new WindowsInstallerData(this.Section.Tuples.First().SourceLineNumbers)
+            {
+                Codepage = this.Section.Codepage,
+                Type = SectionTypeToOutputType(this.Section.Type)
+            };
 
-            this.Output = output;
+            this.AddSectionToOutput();
         }
 
-        private void AddSectionToOutput(IntermediateSection section, WindowsInstallerData output)
+        private void AddSectionToOutput()
         {
-            foreach (var tuple in section.Tuples)
+            foreach (var tuple in this.Section.Tuples)
             {
                 switch (tuple.Definition.Type)
                 {
                 case TupleDefinitionType.AppSearch:
-                    this.AddTupleDefaultly(tuple, output);
-                    output.EnsureTable(this.TableDefinitions["Signature"]);
+                    this.AddTupleDefaultly(tuple);
+                    this.Output.EnsureTable(this.TableDefinitions["Signature"]);
                     break;
 
                 case TupleDefinitionType.Assembly:
-                    this.AddAssemblyTuple((AssemblyTuple)tuple, output);
+                    this.AddAssemblyTuple((AssemblyTuple)tuple);
                     break;
 
                 case TupleDefinitionType.Binary:
-                    this.AddTupleDefaultly(tuple, output, idIsPrimaryKey: true);
+                    this.AddTupleDefaultly(tuple, idIsPrimaryKey: true);
                     break;
 
                 case TupleDefinitionType.BBControl:
-                    this.AddBBControlTuple((BBControlTuple)tuple, output);
+                    this.AddBBControlTuple((BBControlTuple)tuple);
                     break;
 
                 case TupleDefinitionType.Class:
-                    this.AddClassTuple((ClassTuple)tuple, output);
+                    this.AddClassTuple((ClassTuple)tuple);
                     break;
 
                 case TupleDefinitionType.Control:
-                    this.AddControlTuple((ControlTuple)tuple, output);
+                    this.AddControlTuple((ControlTuple)tuple);
                     break;
 
                 case TupleDefinitionType.Component:
-                    this.AddComponentTuple((ComponentTuple)tuple, output);
+                    this.AddComponentTuple((ComponentTuple)tuple);
                     break;
 
                 case TupleDefinitionType.CustomAction:
-                    this.AddCustomActionTuple((CustomActionTuple)tuple, output);
+                    this.AddCustomActionTuple((CustomActionTuple)tuple);
                     break;
 
                 case TupleDefinitionType.Dialog:
-                    this.AddDialogTuple((DialogTuple)tuple, output);
+                    this.AddDialogTuple((DialogTuple)tuple);
                     break;
 
                 case TupleDefinitionType.Directory:
-                    this.AddDirectoryTuple((DirectoryTuple)tuple, output);
+                    this.AddDirectoryTuple((DirectoryTuple)tuple);
                     break;
 
                 case TupleDefinitionType.Environment:
-                    this.AddEnvironmentTuple((EnvironmentTuple)tuple, output);
+                    this.AddEnvironmentTuple((EnvironmentTuple)tuple);
                     break;
 
                 case TupleDefinitionType.Error:
-                    this.AddErrorTuple((ErrorTuple)tuple, output);
+                    this.AddErrorTuple((ErrorTuple)tuple);
                     break;
 
                 case TupleDefinitionType.Feature:
-                    this.AddFeatureTuple((FeatureTuple)tuple, output);
+                    this.AddFeatureTuple((FeatureTuple)tuple);
                     break;
 
                 case TupleDefinitionType.File:
-                    this.AddFileTuple((FileTuple)tuple, output);
+                    this.AddFileTuple((FileTuple)tuple);
                     break;
 
                 case TupleDefinitionType.Icon:
-                    this.AddTupleDefaultly(tuple, output, idIsPrimaryKey: true);
+                    this.AddTupleDefaultly(tuple, idIsPrimaryKey: true);
                     break;
 
                 case TupleDefinitionType.IniFile:
-                    this.AddIniFileTuple((IniFileTuple)tuple, output);
+                    this.AddIniFileTuple((IniFileTuple)tuple);
                     break;
 
                 case TupleDefinitionType.Media:
-                    this.AddMediaTuple((MediaTuple)tuple, output);
+                    this.AddMediaTuple((MediaTuple)tuple);
                     break;
 
                 case TupleDefinitionType.ModuleConfiguration:
-                    this.AddModuleConfigurationTuple((ModuleConfigurationTuple)tuple, output);
+                    this.AddModuleConfigurationTuple((ModuleConfigurationTuple)tuple);
                     break;
 
                 case TupleDefinitionType.MsiEmbeddedUI:
-                    this.AddMsiEmbeddedUITuple((MsiEmbeddedUITuple)tuple, output);
+                    this.AddMsiEmbeddedUITuple((MsiEmbeddedUITuple)tuple);
                     break;
 
                 case TupleDefinitionType.MsiFileHash:
-                    this.AddMsiFileHashTuple((MsiFileHashTuple)tuple, output);
+                    this.AddMsiFileHashTuple((MsiFileHashTuple)tuple);
                     break;
 
                 case TupleDefinitionType.MsiServiceConfig:
-                    this.AddMsiServiceConfigTuple((MsiServiceConfigTuple)tuple, output);
+                    this.AddMsiServiceConfigTuple((MsiServiceConfigTuple)tuple);
                     break;
 
                 case TupleDefinitionType.MsiServiceConfigFailureActions:
-                    this.AddMsiServiceConfigFailureActionsTuple((MsiServiceConfigFailureActionsTuple)tuple, output);
+                    this.AddMsiServiceConfigFailureActionsTuple((MsiServiceConfigFailureActionsTuple)tuple);
                     break;
 
                 case TupleDefinitionType.MsiShortcutProperty:
-                    this.AddTupleDefaultly(tuple, output, idIsPrimaryKey: true);
+                    this.AddTupleDefaultly(tuple, idIsPrimaryKey: true);
                     break;
 
                 case TupleDefinitionType.MoveFile:
-                    this.AddMoveFileTuple((MoveFileTuple)tuple, output);
+                    this.AddMoveFileTuple((MoveFileTuple)tuple);
                     break;
 
                 case TupleDefinitionType.ProgId:
-                    this.AddTupleDefaultly(tuple, output);
-                    output.EnsureTable(this.TableDefinitions["Extension"]);
+                    this.AddTupleDefaultly(tuple);
+                    this.Output.EnsureTable(this.TableDefinitions["Extension"]);
                     break;
 
                 case TupleDefinitionType.Property:
-                    this.AddPropertyTuple((PropertyTuple)tuple, output);
+                    this.AddPropertyTuple((PropertyTuple)tuple);
                     break;
 
                 case TupleDefinitionType.RemoveFile:
-                    this.AddRemoveFileTuple((RemoveFileTuple)tuple, output);
+                    this.AddRemoveFileTuple((RemoveFileTuple)tuple);
                     break;
 
                 case TupleDefinitionType.Registry:
-                    this.AddRegistryTuple((RegistryTuple)tuple, output);
+                    this.AddRegistryTuple((RegistryTuple)tuple);
                     break;
 
                 case TupleDefinitionType.RegLocator:
-                    this.AddRegLocatorTuple((RegLocatorTuple)tuple, output);
+                    this.AddRegLocatorTuple((RegLocatorTuple)tuple);
                     break;
 
                 case TupleDefinitionType.RemoveRegistry:
-                    this.AddRemoveRegistryTuple((RemoveRegistryTuple)tuple, output);
+                    this.AddRemoveRegistryTuple((RemoveRegistryTuple)tuple);
                     break;
 
                 case TupleDefinitionType.ReserveCost:
-                    this.AddTupleDefaultly(tuple, output, idIsPrimaryKey: true);
+                    this.AddTupleDefaultly(tuple, idIsPrimaryKey: true);
                     break;
 
                 case TupleDefinitionType.ServiceControl:
-                    this.AddServiceControlTuple((ServiceControlTuple)tuple, output);
+                    this.AddServiceControlTuple((ServiceControlTuple)tuple);
                     break;
 
                 case TupleDefinitionType.ServiceInstall:
-                    this.AddServiceInstallTuple((ServiceInstallTuple)tuple, output);
+                    this.AddServiceInstallTuple((ServiceInstallTuple)tuple);
                     break;
 
                 case TupleDefinitionType.Shortcut:
-                    this.AddShortcutTuple((ShortcutTuple)tuple, output);
+                    this.AddShortcutTuple((ShortcutTuple)tuple);
                     break;
                         
                 case TupleDefinitionType.Signature:
-                    this.AddTupleDefaultly(tuple, output, idIsPrimaryKey: true);
+                    this.AddTupleDefaultly(tuple, idIsPrimaryKey: true);
                     break;
 
                 case TupleDefinitionType.SummaryInformation:
-                    this.AddTupleDefaultly(tuple, output, tableName: "_SummaryInformation");
+                    this.AddTupleDefaultly(tuple, tableName: "_SummaryInformation");
                     break;
 
                 case TupleDefinitionType.TextStyle:
-                    this.AddTextStyleTuple((TextStyleTuple)tuple, output);
+                    this.AddTextStyleTuple((TextStyleTuple)tuple);
                     break;
 
                 case TupleDefinitionType.Upgrade:
-                    this.AddUpgradeTuple((UpgradeTuple)tuple, output);
+                    this.AddUpgradeTuple((UpgradeTuple)tuple);
                     break;
 
                 case TupleDefinitionType.WixAction:
-                    this.AddWixActionTuple((WixActionTuple)tuple, output);
+                    this.AddWixActionTuple((WixActionTuple)tuple);
                     break;
 
                 case TupleDefinitionType.WixMediaTemplate:
-                    this.AddWixMediaTemplateTuple((WixMediaTemplateTuple)tuple, output);
+                    this.AddWixMediaTemplateTuple((WixMediaTemplateTuple)tuple);
                     break;
 
                 case TupleDefinitionType.MustBeFromAnExtension:
-                    this.AddTupleFromExtension(tuple, output);
+                    this.AddTupleFromExtension(tuple);
                     break;
 
                 case TupleDefinitionType.WixCustomRow:
-                    this.AddWixCustomRowTuple((WixCustomRowTuple)tuple, output);
+                    this.AddWixCustomRowTuple((WixCustomRowTuple)tuple);
                     break;
 
                 case TupleDefinitionType.WixEnsureTable:
-                    this.AddWixEnsureTableTuple((WixEnsureTableTuple)tuple, output);
+                    this.AddWixEnsureTableTuple((WixEnsureTableTuple)tuple);
                     break;
 
                 // ignored.
@@ -234,25 +234,25 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                 case TupleDefinitionType.WixComponentGroup:
                 case TupleDefinitionType.WixDeltaPatchFile:
                 case TupleDefinitionType.WixFeatureGroup:
-                    break;
+                case TupleDefinitionType.WixPatchBaseline:
+                        break;
 
                 // Already processed.
                 case TupleDefinitionType.WixCustomTable:
                     break;
 
                 default:
-                    this.AddTupleDefaultly(tuple, output);
+                    this.AddTupleDefaultly(tuple);
                     break;
                 }
             }
         }
 
-        private void AddAssemblyTuple(AssemblyTuple tuple, WindowsInstallerData output)
+        private void AddAssemblyTuple(AssemblyTuple tuple)
         {
             var attributes = tuple.Type == AssemblyType.Win32Assembly ? 1 : (int?)null;
 
-            var table = output.EnsureTable(this.TableDefinitions["MsiAssembly"]);
-            var row = table.CreateRow(tuple.SourceLineNumbers);
+            var row = this.CreateRow(tuple, "MsiAssembly");
             row[0] = tuple.ComponentRef;
             row[1] = tuple.FeatureRef;
             row[2] = tuple.ManifestFileRef;
@@ -260,7 +260,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             row[4] = attributes;
         }
 
-        private void AddBBControlTuple(BBControlTuple tuple, WindowsInstallerData output)
+        private void AddBBControlTuple(BBControlTuple tuple)
         {
             var attributes = tuple.Attributes;
             attributes |= tuple.Enabled ? WindowsInstallerConstants.MsidbControlAttributesEnabled : 0;
@@ -272,8 +272,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             attributes |= tuple.Sunken ? WindowsInstallerConstants.MsidbControlAttributesSunken : 0;
             attributes |= tuple.Visible ? WindowsInstallerConstants.MsidbControlAttributesVisible : 0;
 
-            var table = output.EnsureTable(this.TableDefinitions["BBControl"]);
-            var row = table.CreateRow(tuple.SourceLineNumbers);
+            var row = this.CreateRow(tuple, "BBControl");
             row[0] = tuple.BillboardRef;
             row[1] = tuple.BBControl;
             row[2] = tuple.Type;
@@ -285,10 +284,9 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             row[8] = tuple.Text;
         }
 
-        private void AddClassTuple(ClassTuple tuple, WindowsInstallerData output)
+        private void AddClassTuple(ClassTuple tuple)
         {
-            var table = output.EnsureTable(this.TableDefinitions["Class"]);
-            var row = table.CreateRow(tuple.SourceLineNumbers);
+            var row = this.CreateRow(tuple, "Class");
             row[0] = tuple.CLSID;
             row[1] = tuple.Context;
             row[2] = tuple.ComponentRef;
@@ -304,7 +302,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             row[12] = tuple.RelativePath ? (int?)1 : null;
         }
 
-        private void AddControlTuple(ControlTuple tuple, WindowsInstallerData output)
+        private void AddControlTuple(ControlTuple tuple)
         {
             var text = tuple.Text;
             var attributes = tuple.Attributes;
@@ -329,8 +327,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                 text = String.Concat(text, " ");
             }
 
-            var table = output.EnsureTable(this.TableDefinitions["Control"]);
-            var row = table.CreateRow(tuple.SourceLineNumbers);
+            var row = this.CreateRow(tuple, "Control");
             row[0] = tuple.DialogRef;
             row[1] = tuple.Control;
             row[2] = tuple.Type;
@@ -344,7 +341,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             row[10] = tuple.Help;
         }
 
-        private void AddComponentTuple(ComponentTuple tuple, WindowsInstallerData output)
+        private void AddComponentTuple(ComponentTuple tuple)
         {
             var attributes = ComponentLocation.Either == tuple.Location ? WindowsInstallerConstants.MsidbComponentAttributesOptional : 0;
             attributes |= ComponentLocation.SourceOnly == tuple.Location ? WindowsInstallerConstants.MsidbComponentAttributesSourceOnly : 0;
@@ -359,8 +356,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             attributes |= tuple.UninstallWhenSuperseded ? WindowsInstallerConstants.MsidbComponentAttributesUninstallOnSupersedence : 0;
             attributes |= tuple.Win64 ? WindowsInstallerConstants.MsidbComponentAttributes64bit : 0;
 
-            var table = output.EnsureTable(this.TableDefinitions["Component"]);
-            var row = table.CreateRow(tuple.SourceLineNumbers);
+            var row = this.CreateRow(tuple, "Component");
             row[0] = tuple.Id.Id;
             row[1] = tuple.ComponentId;
             row[2] = tuple.DirectoryRef;
@@ -369,7 +365,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             row[5] = tuple.KeyPath;
         }
 
-        private void AddCustomActionTuple(CustomActionTuple tuple, WindowsInstallerData output)
+        private void AddCustomActionTuple(CustomActionTuple tuple)
         {
             var type = tuple.Win64 ? WindowsInstallerConstants.MsidbCustomActionType64BitScript : 0;
             type |= tuple.IgnoreResult ? WindowsInstallerConstants.MsidbCustomActionTypeContinue : 0;
@@ -396,8 +392,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                 type |= tuple.TSAware ? WindowsInstallerConstants.MsidbCustomActionTypeTSAware : 0;
             }
 
-            var table = output.EnsureTable(this.TableDefinitions["CustomAction"]);
-            var row = table.CreateRow(tuple.SourceLineNumbers);
+            var row = this.CreateRow(tuple, "CustomAction");
             row[0] = tuple.Id.Id;
             row[1] = type;
             row[2] = tuple.Source;
@@ -405,7 +400,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             row[4] = tuple.PatchUninstall ? (int?)WindowsInstallerConstants.MsidbCustomActionTypePatchUninstall : null;
         }
 
-        private void AddDialogTuple(DialogTuple tuple, WindowsInstallerData output)
+        private void AddDialogTuple(DialogTuple tuple)
         {
             var attributes = tuple.Visible ? WindowsInstallerConstants.MsidbDialogAttributesVisible : 0;
             attributes|= tuple.Modal ? WindowsInstallerConstants.MsidbDialogAttributesModal : 0;
@@ -419,8 +414,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             attributes|= tuple.SystemModal ? WindowsInstallerConstants.MsidbDialogAttributesSysModal : 0;
             attributes|= tuple.TrackDiskSpace ? WindowsInstallerConstants.MsidbDialogAttributesTrackDiskSpace : 0;
 
-            var table = output.EnsureTable(this.TableDefinitions["Dialog"]);
-            var row = table.CreateRow(tuple.SourceLineNumbers);
+            var row = this.CreateRow(tuple, "Dialog");
             row[0] = tuple.Id.Id;
             row[1] = tuple.HCentering;
             row[2] = tuple.VCentering;
@@ -432,10 +426,10 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             row[8] = tuple.DefaultControlRef;
             row[9] = tuple.CancelControlRef;
 
-            output.EnsureTable(this.TableDefinitions["ListBox"]);
+            this.Output.EnsureTable(this.TableDefinitions["ListBox"]);
         }
 
-        private void AddDirectoryTuple(DirectoryTuple tuple, WindowsInstallerData output)
+        private void AddDirectoryTuple(DirectoryTuple tuple)
         {
             var sourceName = GetMsiFilenameValue(tuple.SourceShortName, tuple.SourceName);
             var targetName = GetMsiFilenameValue(tuple.ShortName, tuple.Name);
@@ -447,14 +441,13 @@ namespace WixToolset.Core.WindowsInstaller.Bind
 
             var defaultDir = String.IsNullOrEmpty(sourceName) ? targetName :  targetName + ":" + sourceName ;
 
-            var table = output.EnsureTable(this.TableDefinitions["Directory"]);
-            var row = table.CreateRow(tuple.SourceLineNumbers);
+            var row = this.CreateRow(tuple, "Directory");
             row[0] = tuple.Id.Id;
             row[1] = tuple.ParentDirectoryRef;
             row[2] = defaultDir;
         }
 
-        private void AddEnvironmentTuple(EnvironmentTuple tuple, WindowsInstallerData output)
+        private void AddEnvironmentTuple(EnvironmentTuple tuple)
         {
             var action = String.Empty;
             var system = tuple.System ? "*" : String.Empty;
@@ -484,23 +477,21 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                 break;
             }
 
-            var table = output.EnsureTable(this.TableDefinitions["Environment"]);
-            var row = table.CreateRow(tuple.SourceLineNumbers);
+            var row = this.CreateRow(tuple, "Environment");
             row[0] = tuple.Id.Id;
             row[1] = String.Concat(action, uninstall, system, tuple.Name);
             row[2] = value;
             row[3] = tuple.ComponentRef;
         }
 
-        private void AddErrorTuple(ErrorTuple tuple, WindowsInstallerData output)
+        private void AddErrorTuple(ErrorTuple tuple)
         {
-            var table = output.EnsureTable(this.TableDefinitions["Error"]);
-            var row = table.CreateRow(tuple.SourceLineNumbers);
+            var row = this.CreateRow(tuple, "Error");
             row[0] = Convert.ToInt32(tuple.Id.Id);
             row[1] = tuple.Message;
         }
 
-        private void AddFeatureTuple(FeatureTuple tuple, WindowsInstallerData output)
+        private void AddFeatureTuple(FeatureTuple tuple)
         {
             var attributes = tuple.DisallowAbsent ? WindowsInstallerConstants.MsidbFeatureAttributesUIDisallowAbsent : 0;
             attributes |= tuple.DisallowAdvertise ? WindowsInstallerConstants.MsidbFeatureAttributesDisallowAdvertise : 0;
@@ -508,8 +499,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             attributes |= FeatureInstallDefault.Source == tuple.InstallDefault ? WindowsInstallerConstants.MsidbFeatureAttributesFavorSource : 0;
             attributes |= FeatureTypicalDefault.Advertise == tuple.TypicalDefault ? WindowsInstallerConstants.MsidbFeatureAttributesFavorAdvertise : 0;
 
-            var table = output.EnsureTable(this.TableDefinitions["Feature"]);
-            var row = table.CreateRow(tuple.SourceLineNumbers);
+            var row = this.CreateRow(tuple, "Feature");
             row[0] = tuple.Id.Id;
             row[1] = tuple.ParentFeatureRef;
             row[2] = tuple.Title;
@@ -520,16 +510,17 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             row[7] = attributes;
         }
 
-        private void AddFileTuple(FileTuple tuple, WindowsInstallerData output)
+        private void AddFileTuple(FileTuple tuple)
         {
-            var table = output.EnsureTable(this.TableDefinitions["File"]);
-            var row = (FileRow)table.CreateRow(tuple.SourceLineNumbers);
+            var row = (FileRow)this.CreateRow(tuple, "File");
             row.File = tuple.Id.Id;
             row.Component = tuple.ComponentRef;
             row.FileName = GetMsiFilenameValue(tuple.ShortName, tuple.Name);
             row.FileSize = tuple.FileSize;
             row.Version = tuple.Version;
             row.Language = tuple.Language;
+            row.DiskId = tuple.DiskId ?? 1; // TODO: is 0 the correct thing to default here
+            row.Source = tuple.Source.Path;
 
             var attributes = (tuple.Attributes & FileTupleAttributes.Checksum) == FileTupleAttributes.Checksum ? WindowsInstallerConstants.MsidbFileAttributesChecksum : 0;
             attributes |= (tuple.Attributes & FileTupleAttributes.Compressed) == FileTupleAttributes.Compressed ? WindowsInstallerConstants.MsidbFileAttributesCompressed : 0;
@@ -542,19 +533,17 @@ namespace WixToolset.Core.WindowsInstaller.Bind
 
             if (!String.IsNullOrEmpty(tuple.FontTitle))
             {
-                var fontTable = output.EnsureTable(this.TableDefinitions["Font"]);
-                var fontRow = fontTable.CreateRow(tuple.SourceLineNumbers);
+                var fontRow = this.CreateRow(tuple, "Font");
                 fontRow[0] = tuple.Id.Id;
                 fontRow[1] = tuple.FontTitle;
             }
         }
 
-        private void AddIniFileTuple(IniFileTuple tuple, WindowsInstallerData output)
+        private void AddIniFileTuple(IniFileTuple tuple)
         {
             var tableName = (InifFileActionType.AddLine == tuple.Action || InifFileActionType.AddTag == tuple.Action || InifFileActionType.CreateLine == tuple.Action) ? "IniFile" : "RemoveIniFile";
 
-            var table = output.EnsureTable(this.TableDefinitions[tableName]);
-            var row = table.CreateRow(tuple.SourceLineNumbers);
+            var row = this.CreateRow(tuple, tableName);
             row[0] = tuple.Id.Id;
             row[1] = tuple.FileName;
             row[2] = tuple.DirProperty;
@@ -565,12 +554,11 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             row[7] = tuple.ComponentRef;
         }
 
-        private void AddMediaTuple(MediaTuple tuple, WindowsInstallerData output)
+        private void AddMediaTuple(MediaTuple tuple)
         {
             if (this.Section.Type != SectionType.Module)
             {
-                var table = output.EnsureTable(this.TableDefinitions["Media"]);
-                var row = (MediaRow)table.CreateRow(tuple.SourceLineNumbers);
+                var row = (MediaRow)this.CreateRow(tuple, "Media");
                 row.DiskId = tuple.DiskId;
                 row.LastSequence = tuple.LastSequence ?? 0;
                 row.DiskPrompt = tuple.DiskPrompt;
@@ -580,10 +568,9 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             }
         }
 
-        private void AddModuleConfigurationTuple(ModuleConfigurationTuple tuple, WindowsInstallerData output)
+        private void AddModuleConfigurationTuple(ModuleConfigurationTuple tuple)
         {
-            var table = output.EnsureTable(this.TableDefinitions["ModuleConfiguration"]);
-            var row = table.CreateRow(tuple.SourceLineNumbers);
+            var row = this.CreateRow(tuple, "ModuleConfiguration");
             row[0] = tuple.Id.Id;
             row[1] = tuple.Format;
             row[2] = tuple.Type;
@@ -597,13 +584,12 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             row[9] = tuple.HelpKeyword;
         }
 
-        private void AddMsiEmbeddedUITuple(MsiEmbeddedUITuple tuple, WindowsInstallerData output)
+        private void AddMsiEmbeddedUITuple(MsiEmbeddedUITuple tuple)
         {
             var attributes = tuple.EntryPoint ? WindowsInstallerConstants.MsidbEmbeddedUI : 0;
             attributes |= tuple.SupportsBasicUI ? WindowsInstallerConstants.MsidbEmbeddedHandlesBasic : 0;
 
-            var table = output.EnsureTable(this.TableDefinitions["MsiEmbeddedUI"]);
-            var row = table.CreateRow(tuple.SourceLineNumbers);
+            var row = this.CreateRow(tuple, "MsiEmbeddedUI");
             row[0] = tuple.Id.Id;
             row[1] = tuple.FileName;
             row[2] = attributes;
@@ -611,10 +597,9 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             row[4] = tuple.Source;
         }
 
-        private void AddMsiFileHashTuple(MsiFileHashTuple tuple, WindowsInstallerData output)
+        private void AddMsiFileHashTuple(MsiFileHashTuple tuple)
         {
-            var table = output.EnsureTable(this.TableDefinitions["MsiFileHash"]);
-            var row = table.CreateRow(tuple.SourceLineNumbers);
+            var row = this.CreateRow(tuple, "MsiFileHash");
             row[0] = tuple.Id.Id;
             row[1] = tuple.Options;
             row[2] = tuple.HashPart1;
@@ -623,14 +608,13 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             row[5] = tuple.HashPart4;
         }
 
-        private void AddMsiServiceConfigTuple(MsiServiceConfigTuple tuple, WindowsInstallerData output)
+        private void AddMsiServiceConfigTuple(MsiServiceConfigTuple tuple)
         {
             var events = tuple.OnInstall ? WindowsInstallerConstants.MsidbServiceConfigEventInstall : 0;
             events |= tuple.OnReinstall ? WindowsInstallerConstants.MsidbServiceConfigEventReinstall : 0;
             events |= tuple.OnUninstall ? WindowsInstallerConstants.MsidbServiceConfigEventUninstall : 0;
 
-            var table = output.EnsureTable(this.TableDefinitions["MsiServiceConfigFailureActions"]);
-            var row = table.CreateRow(tuple.SourceLineNumbers);
+            var row = this.CreateRow(tuple, "MsiServiceConfigFailureActions");
             row[0] = tuple.Id.Id;
             row[1] = tuple.Name;
             row[2] = events;
@@ -639,14 +623,13 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             row[5] = tuple.ComponentRef;
         }
 
-        private void AddMsiServiceConfigFailureActionsTuple(MsiServiceConfigFailureActionsTuple tuple, WindowsInstallerData output)
+        private void AddMsiServiceConfigFailureActionsTuple(MsiServiceConfigFailureActionsTuple tuple)
         {
             var events = tuple.OnInstall ? WindowsInstallerConstants.MsidbServiceConfigEventInstall : 0;
             events |= tuple.OnReinstall ? WindowsInstallerConstants.MsidbServiceConfigEventReinstall : 0;
             events |= tuple.OnUninstall ? WindowsInstallerConstants.MsidbServiceConfigEventUninstall : 0;
 
-            var table = output.EnsureTable(this.TableDefinitions["MsiServiceConfig"]);
-            var row = table.CreateRow(tuple.SourceLineNumbers);
+            var row = this.CreateRow(tuple, "MsiServiceConfig");
             row[0] = tuple.Id.Id;
             row[1] = tuple.Name;
             row[2] = events;
@@ -658,10 +641,9 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             row[8] = tuple.ComponentRef;
         }
 
-        private void AddMoveFileTuple(MoveFileTuple tuple, WindowsInstallerData output)
+        private void AddMoveFileTuple(MoveFileTuple tuple)
         {
-            var table = output.EnsureTable(this.TableDefinitions["MoveFile"]);
-            var row = table.CreateRow(tuple.SourceLineNumbers);
+            var row = this.CreateRow(tuple, "MoveFile");
             row[0] = tuple.Id.Id;
             row[1] = tuple.ComponentRef;
             row[2] = tuple.SourceName;
@@ -671,26 +653,24 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             row[6] = tuple.Delete ? WindowsInstallerConstants.MsidbMoveFileOptionsMove : 0;
         }
 
-        private void AddPropertyTuple(PropertyTuple tuple, WindowsInstallerData output)
+        private void AddPropertyTuple(PropertyTuple tuple)
         {
             if (String.IsNullOrEmpty(tuple.Value))
             {
                 return;
             }
 
-            var table = output.EnsureTable(this.TableDefinitions["Property"]);
-            var row = (PropertyRow)table.CreateRow(tuple.SourceLineNumbers);
+            var row = (PropertyRow)this.CreateRow(tuple, "Property");
             row.Property = tuple.Id.Id;
             row.Value = tuple.Value;
         }
 
-        private void AddRemoveFileTuple(RemoveFileTuple tuple, WindowsInstallerData output)
+        private void AddRemoveFileTuple(RemoveFileTuple tuple)
         {
             var installMode = tuple.OnInstall == true ? WindowsInstallerConstants.MsidbRemoveFileInstallModeOnInstall : 0;
             installMode |= tuple.OnUninstall == true ? WindowsInstallerConstants.MsidbRemoveFileInstallModeOnRemove : 0;
 
-            var table = output.EnsureTable(this.TableDefinitions["RemoveFile"]);
-            var row = table.CreateRow(tuple.SourceLineNumbers);
+            var row = this.CreateRow(tuple, "RemoveFile");
             row[0] = tuple.Id.Id;
             row[1] = tuple.ComponentRef;
             row[2] = tuple.FileName;
@@ -698,7 +678,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             row[4] = installMode;
         }
 
-        private void AddRegistryTuple(RegistryTuple tuple, WindowsInstallerData output)
+        private void AddRegistryTuple(RegistryTuple tuple)
         {
             var value = tuple.Value;
 
@@ -740,8 +720,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                 break;
             }
 
-            var table = output.EnsureTable(this.TableDefinitions["Registry"]);
-            var row = table.CreateRow(tuple.SourceLineNumbers);
+            var row = this.CreateRow(tuple, "Registry");
             row[0] = tuple.Id.Id;
             row[1] = tuple.Root;
             row[2] = tuple.Key;
@@ -750,13 +729,12 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             row[5] = tuple.ComponentRef;
         }
 
-        private void AddRegLocatorTuple(RegLocatorTuple tuple, WindowsInstallerData output)
+        private void AddRegLocatorTuple(RegLocatorTuple tuple)
         {
             var type = (int)tuple.Type;
             type |= tuple.Win64 ? WindowsInstallerConstants.MsidbLocatorType64bit : 0;
 
-            var table = output.EnsureTable(this.TableDefinitions["RegLocator"]);
-            var row = table.CreateRow(tuple.SourceLineNumbers);
+            var row = this.CreateRow(tuple, "RegLocator");
             row[0] = tuple.Id.Id;
             row[1] = tuple.Root;
             row[2] = tuple.Key;
@@ -764,12 +742,11 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             row[4] = type;
         }
 
-        private void AddRemoveRegistryTuple(RemoveRegistryTuple tuple, WindowsInstallerData output)
+        private void AddRemoveRegistryTuple(RemoveRegistryTuple tuple)
         {
             if (tuple.Action == RemoveRegistryActionType.RemoveOnInstall)
             {
-                var table = output.EnsureTable(this.TableDefinitions["RemoveRegistry"]);
-                var row = table.CreateRow(tuple.SourceLineNumbers);
+                var row = this.CreateRow(tuple, "RemoveRegistry");
                 row[0] = tuple.Id.Id;
                 row[1] = tuple.Root;
                 row[2] = tuple.Key;
@@ -778,8 +755,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             }
             else // Registry table is used to remove registry keys on uninstall.
             {
-                var table = output.EnsureTable(this.TableDefinitions["Registry"]);
-                var row = table.CreateRow(tuple.SourceLineNumbers);
+                var row = this.CreateRow(tuple, "Registry");
                 row[0] = tuple.Id.Id;
                 row[1] = tuple.Root;
                 row[2] = tuple.Key;
@@ -788,7 +764,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             }
         }
 
-        private void AddServiceControlTuple(ServiceControlTuple tuple, WindowsInstallerData output)
+        private void AddServiceControlTuple(ServiceControlTuple tuple)
         {
             var events = tuple.InstallRemove ? WindowsInstallerConstants.MsidbServiceControlEventDelete : 0;
             events |= tuple.UninstallRemove ? WindowsInstallerConstants.MsidbServiceControlEventUninstallDelete : 0;
@@ -797,8 +773,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             events |= tuple.InstallStop ? WindowsInstallerConstants.MsidbServiceControlEventStop : 0;
             events |= tuple.UninstallStop ? WindowsInstallerConstants.MsidbServiceControlEventUninstallStop : 0;
 
-            var table = output.EnsureTable(this.TableDefinitions["ServiceControl"]);
-            var row = table.CreateRow(tuple.SourceLineNumbers);
+            var row = this.CreateRow(tuple, "ServiceControl");
             row[0] = tuple.Id.Id;
             row[1] = tuple.Name;
             row[2] = events;
@@ -810,7 +785,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             row[5] = tuple.ComponentRef;
         }
 
-        private void AddServiceInstallTuple(ServiceInstallTuple tuple, WindowsInstallerData output)
+        private void AddServiceInstallTuple(ServiceInstallTuple tuple)
         {
             var errorControl = (int)tuple.ErrorControl;
             errorControl |= tuple.Vital ? WindowsInstallerConstants.MsidbServiceInstallErrorControlVital : 0;
@@ -818,8 +793,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             var serviceType = (int)tuple.ServiceType;
             serviceType |= tuple.Interactive ? WindowsInstallerConstants.MsidbServiceInstallInteractive : 0;
 
-            var table = output.EnsureTable(this.TableDefinitions["ServiceInstall"]);
-            var row = table.CreateRow(tuple.SourceLineNumbers);
+            var row = this.CreateRow(tuple, "ServiceInstall");
             row[0] = tuple.Id.Id;
             row[1] = tuple.Name;
             row[2] = tuple.DisplayName;
@@ -835,10 +809,9 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             row[12] = tuple.Description;
         }
 
-        private void AddShortcutTuple(ShortcutTuple tuple, WindowsInstallerData output)
+        private void AddShortcutTuple(ShortcutTuple tuple)
         {
-            var table = output.EnsureTable(this.TableDefinitions["Shortcut"]);
-            var row = table.CreateRow(tuple.SourceLineNumbers);
+            var row = this.CreateRow(tuple, "Shortcut");
             row[0] = tuple.Id.Id;
             row[1] = tuple.DirectoryRef;
             row[2] = GetMsiFilenameValue(tuple.ShortName, tuple.Name);
@@ -857,7 +830,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             row[15] = tuple.DescriptionResourceId;
         }
 
-        private void AddTextStyleTuple(TextStyleTuple tuple, WindowsInstallerData output)
+        private void AddTextStyleTuple(TextStyleTuple tuple)
         {
             var styleBits = tuple.Bold ? WindowsInstallerConstants.MsidbTextStyleStyleBitsBold : 0;
             styleBits |= tuple.Italic ? WindowsInstallerConstants.MsidbTextStyleStyleBitsItalic : 0;
@@ -873,8 +846,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                 color += (long)(tuple.Blue ?? 0) * 65536;
             }
 
-            var table = output.EnsureTable(this.TableDefinitions["TextStyle"]);
-            var row = table.CreateRow(tuple.SourceLineNumbers);
+            var row = this.CreateRow(tuple, "TextStyle");
             row[0] = tuple.Id.Id;
             row[1] = tuple.FaceName;
             row[2] = tuple.Size;
@@ -882,10 +854,9 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             row[4] = styleBits == 0 ? null : (int?)styleBits;
         }
 
-        private void AddUpgradeTuple(UpgradeTuple tuple, WindowsInstallerData output)
+        private void AddUpgradeTuple(UpgradeTuple tuple)
         {
-            var table = output.EnsureTable(this.TableDefinitions["Upgrade"]);
-            var row = (UpgradeRow)table.CreateRow(tuple.SourceLineNumbers);
+            var row = (UpgradeRow)this.CreateRow(tuple, "Upgrade");
             row.UpgradeCode = tuple.UpgradeCode;
             row.VersionMin = tuple.VersionMin;
             row.VersionMax = tuple.VersionMax;
@@ -902,72 +873,71 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             row.Attributes = attributes;
         }
 
-        private void AddWixActionTuple(WixActionTuple tuple, WindowsInstallerData output)
+        private void AddWixActionTuple(WixActionTuple tuple)
         {
             // Get the table definition for the action (and ensure the proper table exists for a module).
-            TableDefinition sequenceTableDefinition = null;
+            string sequenceTableName = null;
             switch (tuple.SequenceTable)
             {
                 case SequenceTable.AdminExecuteSequence:
-                    if (OutputType.Module == output.Type)
+                    if (OutputType.Module == this.Output.Type)
                     {
-                        output.EnsureTable(this.TableDefinitions["AdminExecuteSequence"]);
-                        sequenceTableDefinition = this.TableDefinitions["ModuleAdminExecuteSequence"];
+                        this.Output.EnsureTable(this.TableDefinitions["AdminExecuteSequence"]);
+                        sequenceTableName = "ModuleAdminExecuteSequence";
                     }
                     else
                     {
-                        sequenceTableDefinition = this.TableDefinitions["AdminExecuteSequence"];
+                        sequenceTableName = "AdminExecuteSequence";
                     }
                     break;
                 case SequenceTable.AdminUISequence:
-                    if (OutputType.Module == output.Type)
+                    if (OutputType.Module == this.Output.Type)
                     {
-                        output.EnsureTable(this.TableDefinitions["AdminUISequence"]);
-                        sequenceTableDefinition = this.TableDefinitions["ModuleAdminUISequence"];
+                        this.Output.EnsureTable(this.TableDefinitions["AdminUISequence"]);
+                        sequenceTableName = "ModuleAdminUISequence";
                     }
                     else
                     {
-                        sequenceTableDefinition = this.TableDefinitions["AdminUISequence"];
+                        sequenceTableName = "AdminUISequence";
                     }
                     break;
                 case SequenceTable.AdvertiseExecuteSequence:
-                    if (OutputType.Module == output.Type)
+                    if (OutputType.Module == this.Output.Type)
                     {
-                        output.EnsureTable(this.TableDefinitions["AdvtExecuteSequence"]);
-                        sequenceTableDefinition = this.TableDefinitions["ModuleAdvtExecuteSequence"];
+                        this.Output.EnsureTable(this.TableDefinitions["AdvtExecuteSequence"]);
+                        sequenceTableName = "ModuleAdvtExecuteSequence";
                     }
                     else
                     {
-                        sequenceTableDefinition = this.TableDefinitions["AdvtExecuteSequence"];
+                        sequenceTableName = "AdvtExecuteSequence";
                     }
                     break;
                 case SequenceTable.InstallExecuteSequence:
-                    if (OutputType.Module == output.Type)
+                    if (OutputType.Module == this.Output.Type)
                     {
-                        output.EnsureTable(this.TableDefinitions["InstallExecuteSequence"]);
-                        sequenceTableDefinition = this.TableDefinitions["ModuleInstallExecuteSequence"];
+                        this.Output.EnsureTable(this.TableDefinitions["InstallExecuteSequence"]);
+                        sequenceTableName = "ModuleInstallExecuteSequence";
                     }
                     else
                     {
-                        sequenceTableDefinition = this.TableDefinitions["InstallExecuteSequence"];
+                        sequenceTableName = "InstallExecuteSequence";
                     }
                     break;
                 case SequenceTable.InstallUISequence:
-                    if (OutputType.Module == output.Type)
+                    if (OutputType.Module == this.Output.Type)
                     {
-                        output.EnsureTable(this.TableDefinitions["InstallUISequence"]);
-                        sequenceTableDefinition = this.TableDefinitions["ModuleInstallUISequence"];
+                        this.Output.EnsureTable(this.TableDefinitions["InstallUISequence"]);
+                        sequenceTableName = "ModuleInstallUISequence";
                     }
                     else
                     {
-                        sequenceTableDefinition = this.TableDefinitions["InstallUISequence"];
+                        sequenceTableName = "InstallUISequence";
                     }
                     break;
             }
 
             // create the action sequence row in the output
-            var sequenceTable = output.EnsureTable(sequenceTableDefinition);
-            var row = sequenceTable.CreateRow(tuple.SourceLineNumbers);
+            var row = this.CreateRow(tuple, sequenceTableName);
 
             if (SectionType.Module == this.Section.Type)
             {
@@ -992,7 +962,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             }
         }
         
-        private void AddWixCustomRowTuple(WixCustomRowTuple tuple, WindowsInstallerData output)
+        private void AddWixCustomRowTuple(WixCustomRowTuple tuple)
         {
             var customTableDefinition = this.TableDefinitions[tuple.Table];
 
@@ -1002,8 +972,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                 return;
             }
 
-            var customTable = output.EnsureTable(customTableDefinition);
-            var customRow = customTable.CreateRow(tuple.SourceLineNumbers);
+            var customRow = this.CreateRow(tuple, customTableDefinition);
 
 #if TODO // SectionId seems like a good thing to preserve.
             customRow.SectionId = tuple.SectionId;
@@ -1073,16 +1042,15 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             }
         }
 
-        private void AddWixEnsureTableTuple(WixEnsureTableTuple tuple, WindowsInstallerData output)
+        private void AddWixEnsureTableTuple(WixEnsureTableTuple tuple)
         {
             var tableDefinition = this.TableDefinitions[tuple.Table];
-            output.EnsureTable(tableDefinition);
+            this.Output.EnsureTable(tableDefinition);
         }
 
-        private void AddWixMediaTemplateTuple(WixMediaTemplateTuple tuple, WindowsInstallerData output)
+        private void AddWixMediaTemplateTuple(WixMediaTemplateTuple tuple)
         {
-            var table = output.EnsureTable(this.TableDefinitions["WixMediaTemplate"]);
-            var row = (WixMediaTemplateRow)table.CreateRow(tuple.SourceLineNumbers);
+            var row = (WixMediaTemplateRow)this.CreateRow(tuple, "WixMediaTemplate");
             row.CabinetTemplate = tuple.CabinetTemplate;
             row.CompressionLevel = tuple.CompressionLevel;
             row.DiskPrompt = tuple.DiskPrompt;
@@ -1091,26 +1059,25 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             row.MaximumCabinetSizeForLargeFileSplitting = tuple.MaximumCabinetSizeForLargeFileSplitting ?? MaxValueOfMaxCabSizeForLargeFileSplitting;
         }
 
-        private void AddTupleFromExtension(IntermediateTuple tuple, WindowsInstallerData output)
+        private void AddTupleFromExtension(IntermediateTuple tuple)
         {
             foreach (var extension in this.BackendExtensions)
             {
-                if (extension.TryAddTupleToOutput(tuple, output))
+                if (extension.TryAddTupleToOutput(tuple, this.Output))
                 {
                     break;
                 }
             }
         }
 
-        private void AddTupleDefaultly(IntermediateTuple tuple, WindowsInstallerData output, bool idIsPrimaryKey = false, string tableName = null)
+        private void AddTupleDefaultly(IntermediateTuple tuple, bool idIsPrimaryKey = false, string tableName = null)
         {
             if (!this.TableDefinitions.TryGet(tableName ?? tuple.Definition.Name, out var tableDefinition))
             {
                 return;
             }
 
-            var table = output.EnsureTable(tableDefinition);
-            var row = table.CreateRow(tuple.SourceLineNumbers);
+            var row = this.CreateRow(tuple, tableDefinition);
             var rowOffset = 0;
 
             if (idIsPrimaryKey)
@@ -1159,6 +1126,18 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             }
         }
 
+        private Row CreateRow(IntermediateTuple tuple, string tableDefinitionName) => this.CreateRow(tuple, this.TableDefinitions[tableDefinitionName]);
+
+        private Row CreateRow(IntermediateTuple tuple, TableDefinition tableDefinition)
+        {
+            var table = this.Output.EnsureTable(tableDefinition);
+
+            var row = table.CreateRow(tuple.SourceLineNumbers);
+            row.SectionId = this.Section.Id;
+
+            return row;
+        }
+
         private static string GetMsiFilenameValue(string shortName, string longName)
         {
             if (String.IsNullOrEmpty(shortName) || String.Equals(shortName, longName, StringComparison.OrdinalIgnoreCase))
diff --git a/src/WixToolset.Core.WindowsInstaller/Bind/CreatePatchTransformsCommand.cs b/src/WixToolset.Core.WindowsInstaller/Bind/CreatePatchTransformsCommand.cs
new file mode 100644
index 00000000..854d973e
--- /dev/null
+++ b/src/WixToolset.Core.WindowsInstaller/Bind/CreatePatchTransformsCommand.cs
@@ -0,0 +1,90 @@
+// 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.Collections.Generic;
+    using System.IO;
+    using System.Linq;
+    using WixToolset.Core.WindowsInstaller.Msi;
+    using WixToolset.Core.WindowsInstaller.Unbind;
+    using WixToolset.Data;
+    using WixToolset.Data.Tuples;
+    using WixToolset.Data.WindowsInstaller;
+    using WixToolset.Extensibility.Services;
+
+    internal class CreatePatchTransformsCommand
+    {
+        public CreatePatchTransformsCommand(IMessaging messaging, Intermediate intermediate, string intermediateFolder)
+        {
+            this.Messaging = messaging;
+            this.Intermediate = intermediate;
+            this.IntermediateFolder = intermediateFolder;
+        }
+
+        private IMessaging Messaging { get; }
+
+        private Intermediate Intermediate { get; }
+
+        private string IntermediateFolder { get; }
+
+        public IEnumerable<PatchTransform> PatchTransforms { get; private set; }
+
+        public IEnumerable<PatchTransform> Execute()
+        {
+            var patchTransforms = new List<PatchTransform>();
+
+            var tuples = this.Intermediate.Sections.SelectMany(s => s.Tuples).OfType<WixPatchBaselineTuple>();
+
+            foreach (var tuple in tuples)
+            {
+                WindowsInstallerData transform;
+
+                if (tuple.TransformFile is null)
+                {
+                    var baselineData = this.GetData(tuple.BaselineFile.Path);
+                    var updateData = this.GetData(tuple.UpdateFile.Path);
+
+                    var command = new GenerateTransformCommand(this.Messaging, baselineData, updateData, 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, tuple.TransformFile.Path, exportBasePath, this.IntermediateFolder);
+                    transform = command.Execute();
+                }
+
+                patchTransforms.Add(new PatchTransform(tuple.Id.Id, transform));
+            }
+
+            this.PatchTransforms = patchTransforms;
+
+            return this.PatchTransforms;
+        }
+
+        private WindowsInstallerData GetData(string path)
+        {
+            var ext = Path.GetExtension(path);
+
+            if (".msi".Equals(ext, StringComparison.OrdinalIgnoreCase))
+            {
+                using (var database = new Database(path, OpenDatabase.ReadOnly))
+                {
+                    var exportBasePath = Path.Combine(this.IntermediateFolder, "_msi"); // TODO: come up with a better path.
+
+                    var isAdminImage = false; // TODO: need a better way to set this
+
+                    var command = new UnbindDatabaseCommand(this.Messaging, database, path, OutputType.Product, exportBasePath, this.IntermediateFolder, isAdminImage, suppressDemodularization: true, skipSummaryInfo: true);
+                    return command.Execute();
+                }
+            }
+            else // assume .wixpdb (or .wixout)
+            {
+                var data = WindowsInstallerData.Load(path, true);
+                return data;
+            }
+        }
+    }
+}
diff --git a/src/WixToolset.Core.WindowsInstaller/Bind/ExtractMergeModuleFilesCommand.cs b/src/WixToolset.Core.WindowsInstaller/Bind/ExtractMergeModuleFilesCommand.cs
index 5412c6f9..49b6a6f8 100644
--- a/src/WixToolset.Core.WindowsInstaller/Bind/ExtractMergeModuleFilesCommand.cs
+++ b/src/WixToolset.Core.WindowsInstaller/Bind/ExtractMergeModuleFilesCommand.cs
@@ -48,7 +48,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
         {
             var mergeModulesFileFacades = new List<FileFacade>();
 
-            IMsmMerge2 merge = MsmInterop.GetMsmMerge();
+            var merge = MsmInterop.GetMsmMerge();
 
             // Index all of the file rows to be able to detect collisions with files in the Merge Modules.
             // It may seem a bit expensive to build up this index solely for the purpose of checking collisions
@@ -57,11 +57,11 @@ 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.File.Id.Id, StringComparer.Ordinal);
+            var indexedFileFacades = this.FileFacades.ToDictionary(f => f.Id, StringComparer.Ordinal);
 
             foreach (var wixMergeRow in this.WixMergeTuples)
             {
-                bool containsFiles = this.CreateFacadesForMergeModuleFiles(wixMergeRow, mergeModulesFileFacades, indexedFileFacades);
+                var containsFiles = this.CreateFacadesForMergeModuleFiles(wixMergeRow, mergeModulesFileFacades, indexedFileFacades);
 
                 // If the module has files and creating layout
                 if (containsFiles && !this.SuppressLayout)
@@ -75,21 +75,21 @@ namespace WixToolset.Core.WindowsInstaller.Bind
 
         private bool CreateFacadesForMergeModuleFiles(WixMergeTuple wixMergeRow, List<FileFacade> mergeModulesFileFacades, Dictionary<string, FileFacade> indexedFileFacades)
         {
-            bool containsFiles = false;
+            var containsFiles = false;
 
             try
             {
                 // read the module's File table to get its FileMediaInformation entries and gather any other information needed from the module.
-                using (Database db = new Database(wixMergeRow.SourceFile, OpenDatabase.ReadOnly))
+                using (var db = new Database(wixMergeRow.SourceFile, OpenDatabase.ReadOnly))
                 {
                     if (db.TableExists("File") && db.TableExists("Component"))
                     {
-                        Dictionary<string, FileFacade> uniqueModuleFileIdentifiers = new Dictionary<string, FileFacade>(StringComparer.OrdinalIgnoreCase);
+                        var uniqueModuleFileIdentifiers = new Dictionary<string, FileFacade>(StringComparer.OrdinalIgnoreCase);
 
-                        using (View view = db.OpenExecuteView("SELECT `File`, `Directory_` FROM `File`, `Component` WHERE `Component_`=`Component`"))
+                        using (var view = db.OpenExecuteView("SELECT `File`, `Directory_` FROM `File`, `Component` WHERE `Component_`=`Component`"))
                         {
                             // add each file row from the merge module into the file row collection (check for errors along the way)
-                            foreach (Record record in view.Records)
+                            foreach (var record in view.Records)
                             {
                                 // NOTE: this is very tricky - the merge module file rows are not added to the
                                 // file table because they should not be created via idt import.  Instead, these
@@ -103,21 +103,21 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                                 var mergeModuleFileFacade = new FileFacade(true, fileTuple);
 
                                 // If case-sensitive collision with another merge module or a user-authored file identifier.
-                                if (indexedFileFacades.TryGetValue(mergeModuleFileFacade.File.Id.Id, out var collidingFacade))
+                                if (indexedFileFacades.TryGetValue(mergeModuleFileFacade.Id, out var collidingFacade))
                                 {
-                                    this.Messaging.Write(ErrorMessages.DuplicateModuleFileIdentifier(wixMergeRow.SourceLineNumbers, wixMergeRow.Id.Id, collidingFacade.File.Id.Id));
+                                    this.Messaging.Write(ErrorMessages.DuplicateModuleFileIdentifier(wixMergeRow.SourceLineNumbers, wixMergeRow.Id.Id, collidingFacade.Id));
                                 }
-                                else if (uniqueModuleFileIdentifiers.TryGetValue(mergeModuleFileFacade.File.Id.Id, out collidingFacade)) // case-insensitive collision with another file identifier in the same merge module
+                                else if (uniqueModuleFileIdentifiers.TryGetValue(mergeModuleFileFacade.Id, out collidingFacade)) // case-insensitive collision with another file identifier in the same merge module
                                 {
-                                    this.Messaging.Write(ErrorMessages.DuplicateModuleCaseInsensitiveFileIdentifier(wixMergeRow.SourceLineNumbers, wixMergeRow.Id.Id, mergeModuleFileFacade.File.Id.Id, collidingFacade.File.Id.Id));
+                                    this.Messaging.Write(ErrorMessages.DuplicateModuleCaseInsensitiveFileIdentifier(wixMergeRow.SourceLineNumbers, wixMergeRow.Id.Id, mergeModuleFileFacade.Id, collidingFacade.Id));
                                 }
                                 else // no collision
                                 {
                                     mergeModulesFileFacades.Add(mergeModuleFileFacade);
 
                                     // Keep updating the indexes as new rows are added.
-                                    indexedFileFacades.Add(mergeModuleFileFacade.File.Id.Id, mergeModuleFileFacade);
-                                    uniqueModuleFileIdentifiers.Add(mergeModuleFileFacade.File.Id.Id, mergeModuleFileFacade);
+                                    indexedFileFacades.Add(mergeModuleFileFacade.Id, mergeModuleFileFacade);
+                                    uniqueModuleFileIdentifiers.Add(mergeModuleFileFacade.Id, mergeModuleFileFacade);
                                 }
 
                                 containsFiles = true;
@@ -126,13 +126,13 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                     }
 
                     // Get the summary information to detect the Schema
-                    using (SummaryInformation summaryInformation = new SummaryInformation(db))
+                    using (var summaryInformation = new SummaryInformation(db))
                     {
-                        string moduleInstallerVersionString = summaryInformation.GetProperty(14);
+                        var moduleInstallerVersionString = summaryInformation.GetProperty(14);
 
                         try
                         {
-                            int moduleInstallerVersion = Convert.ToInt32(moduleInstallerVersionString, CultureInfo.InvariantCulture);
+                            var moduleInstallerVersion = Convert.ToInt32(moduleInstallerVersionString, CultureInfo.InvariantCulture);
                             if (moduleInstallerVersion > this.OutputInstallerVersion)
                             {
                                 this.Messaging.Write(WarningMessages.InvalidHigherInstallerVersionInModule(wixMergeRow.SourceLineNumbers, wixMergeRow.Id.Id, moduleInstallerVersion, this.OutputInstallerVersion));
@@ -159,7 +159,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
 
         private void ExtractFilesFromMergeModule(IMsmMerge2 merge, WixMergeTuple wixMergeRow)
         {
-            bool moduleOpen = false;
+            var moduleOpen = false;
             short mergeLanguage;
 
             var mergeId = wixMergeRow.Id.Id;
@@ -180,10 +180,10 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                 moduleOpen = true;
 
                 // extract the module cabinet, then explode all of the files to a temp directory
-                string moduleCabPath = Path.Combine(this.IntermediateFolder, mergeId + ".cab");
+                var moduleCabPath = Path.Combine(this.IntermediateFolder, mergeId + ".cab");
                 merge.ExtractCAB(moduleCabPath);
 
-                string mergeIdPath = Path.Combine(this.IntermediateFolder, mergeId);
+                var mergeIdPath = Path.Combine(this.IntermediateFolder, mergeId);
                 Directory.CreateDirectory(mergeIdPath);
 
                 try
diff --git a/src/WixToolset.Core.WindowsInstaller/Bind/GenerateDatabaseCommand.cs b/src/WixToolset.Core.WindowsInstaller/Bind/GenerateDatabaseCommand.cs
index 6b365ecd..ed3b6f01 100644
--- a/src/WixToolset.Core.WindowsInstaller/Bind/GenerateDatabaseCommand.cs
+++ b/src/WixToolset.Core.WindowsInstaller/Bind/GenerateDatabaseCommand.cs
@@ -5,367 +5,396 @@ namespace WixToolset.Core.WindowsInstaller.Bind
     using System;
     using System.Collections.Generic;
     using System.ComponentModel;
-    using System.Globalization;
     using System.IO;
     using System.Text;
+    using WixToolset.Core.WindowsInstaller.Msi;
     using WixToolset.Data;
-    using WixToolset.Extensibility;
     using WixToolset.Data.WindowsInstaller;
-    using WixToolset.Extensibility.Services;
+    using WixToolset.Extensibility;
     using WixToolset.Extensibility.Data;
-    using WixToolset.Core.WindowsInstaller.Msi;
+    using WixToolset.Extensibility.Services;
 
-    internal class GenerateDatabaseCommand 
+    internal class GenerateDatabaseCommand
     {
-        public int Codepage { private get; set; }
+        public GenerateDatabaseCommand(IMessaging messaging, IBackendHelper backendHelper, IEnumerable<IFileSystemExtension> fileSystemExtensions, WindowsInstallerData data, string outputPath, TableDefinitionCollection tableDefinitions, string intermediateFolder, int codepage, bool keepAddedColumns, bool suppressAddingValidationRows, bool useSubdirectory)
+        {
+            this.Messaging = messaging;
+            this.BackendHelper = backendHelper;
+            this.Extensions = fileSystemExtensions;
+            this.Data = data;
+            this.OutputPath = outputPath;
+            this.TableDefinitions = tableDefinitions;
+            this.IntermediateFolder = intermediateFolder;
+            this.Codepage = codepage;
+            this.KeepAddedColumns = keepAddedColumns;
+            this.SuppressAddingValidationRows = suppressAddingValidationRows;
+            this.UseSubDirectory = useSubdirectory;
+        }
+
+        private int Codepage { get; }
 
-        public IBackendHelper BackendHelper { private get; set; }
+        private IBackendHelper BackendHelper { get; }
 
-        public IEnumerable<IFileSystemExtension> Extensions { private get; set; }
+        private IEnumerable<IFileSystemExtension> Extensions { get; }
 
         /// <summary>
         /// Whether to keep columns added in a transform.
         /// </summary>
-        public bool KeepAddedColumns { private get; set; }
+        private bool KeepAddedColumns { get; }
 
-        public IMessaging Messaging { private get; set; }
+        private IMessaging Messaging { get; }
 
-        public WindowsInstallerData Output { private get; set; }
+        private WindowsInstallerData Data { get; }
 
-        public string OutputPath { private get; set; }
+        private string OutputPath { get; }
 
-        public TableDefinitionCollection TableDefinitions { private get; set; }
+        private TableDefinitionCollection TableDefinitions { get; }
 
-        public string IntermediateFolder { private get; set; }
+        private string IntermediateFolder { get; }
 
         public List<ITrackedFile> GeneratedTemporaryFiles { get; } = new List<ITrackedFile>();
 
         /// <summary>
         /// Whether to use a subdirectory based on the <paramref name="databaseFile"/> file name for intermediate files.
         /// </summary>
-        public bool SuppressAddingValidationRows { private get; set; }
+        private bool SuppressAddingValidationRows { get; }
 
-        public bool UseSubDirectory { private get; set; }
+        private bool UseSubDirectory { get; }
 
         public void Execute()
         {
             // Add the _Validation rows.
             if (!this.SuppressAddingValidationRows)
             {
-                var validationTable = this.Output.EnsureTable(this.TableDefinitions["_Validation"]);
-
-                foreach (var table in this.Output.Tables)
-                {
-                    if (!table.Definition.Unreal)
-                    {
-                        // Add the validation rows for this table.
-                        foreach (ColumnDefinition columnDef in table.Definition.Columns)
-                        {
-                            var row = validationTable.CreateRow(null);
-
-                            row[0] = table.Name;
-
-                            row[1] = columnDef.Name;
-
-                            if (columnDef.Nullable)
-                            {
-                                row[2] = "Y";
-                            }
-                            else
-                            {
-                                row[2] = "N";
-                            }
-
-                            if (columnDef.MinValue.HasValue)
-                            {
-                                row[3] = columnDef.MinValue.Value;
-                            }
-
-                            if (columnDef.MaxValue.HasValue)
-                            {
-                                row[4] = columnDef.MaxValue.Value;
-                            }
-
-                            row[5] = columnDef.KeyTable;
-
-                            if (columnDef.KeyColumn.HasValue)
-                            {
-                                row[6] = columnDef.KeyColumn.Value;
-                            }
-
-                            if (ColumnCategory.Unknown != columnDef.Category)
-                            {
-                                row[7] = columnDef.Category.ToString();
-                            }
-
-                            row[8] = columnDef.Possibilities;
-
-                            row[9] = columnDef.Description;
-                        }
-                    }
-                }
+                this.AddValidationRows();
             }
 
-            // Set the base directory.
             var baseDirectory = this.IntermediateFolder;
 
             if (this.UseSubDirectory)
             {
-                string filename = Path.GetFileNameWithoutExtension(this.OutputPath);
+                var filename = Path.GetFileNameWithoutExtension(this.OutputPath);
                 baseDirectory = Path.Combine(baseDirectory, filename);
-
-                // make sure the directory exists
-                Directory.CreateDirectory(baseDirectory);
             }
 
-            var idtDirectory = Path.Combine(baseDirectory, "_idts");
-            Directory.CreateDirectory(idtDirectory);
+            var idtFolder = Path.Combine(baseDirectory, "_idts");
 
-            try
+            var type = OpenDatabase.CreateDirect;
+
+            if (OutputType.Patch == this.Data.Type)
             {
-                OpenDatabase type = OpenDatabase.CreateDirect;
+                type |= OpenDatabase.OpenPatchFile;
+            }
 
-                // set special flag for patch files
-                if (OutputType.Patch == this.Output.Type)
-                {
-                    type |= OpenDatabase.OpenPatchFile;
-                }
+            // Localize the codepage if a value was specified directly.
+            if (-1 != this.Codepage)
+            {
+                this.Data.Codepage = this.Codepage;
+            }
 
+            try
+            {
 #if DEBUG
                 Console.WriteLine("Opening database at: {0}", this.OutputPath);
 #endif
 
-                // Localize the codepage if a value was specified directly.
-                if (-1 != this.Codepage)
-                {
-                    this.Output.Codepage = this.Codepage;
-                }
-
                 Directory.CreateDirectory(Path.GetDirectoryName(this.OutputPath));
 
-                using (Database db = new Database(this.OutputPath, type))
+                Directory.CreateDirectory(idtFolder);
+
+                using (var db = new Database(this.OutputPath, type))
                 {
-                    // if we're not using the default codepage, import a new one into our
+                    // If we're not using the default codepage, import a new one into our
                     // database before we add any tables (or the tables would be added
                     // with the wrong codepage).
-                    if (0 != this.Output.Codepage)
+                    if (0 != this.Data.Codepage)
                     {
-                        this.SetDatabaseCodepage(db, this.Output.Codepage, idtDirectory);
+                        this.SetDatabaseCodepage(db, this.Data.Codepage, idtFolder);
                     }
 
-                    foreach (Table table in this.Output.Tables)
+                    this.ImportTables(db, idtFolder);
+
+                    // Insert substorages (usually transforms inside a patch or instance transforms in a package).
+                    this.ImportSubStorages(db);
+
+                    // We're good, commit the changes to the new database.
+                    db.Commit();
+                }
+            }
+            catch (IOException e)
+            {
+                // TODO: this error message doesn't seem specific enough
+                throw new WixException(ErrorMessages.FileNotFound(new SourceLineNumber(this.OutputPath), this.OutputPath), e);
+            }
+        }
+
+        private void AddValidationRows()
+        {
+            var validationTable = this.Data.EnsureTable(this.TableDefinitions["_Validation"]);
+
+            foreach (var table in this.Data.Tables)
+            {
+                if (!table.Definition.Unreal)
+                {
+                    // Add the validation rows for this table.
+                    foreach (var columnDef in table.Definition.Columns)
                     {
-                        Table importTable = table;
-                        bool hasBinaryColumn = false;
+                        var row = validationTable.CreateRow(null);
+
+                        row[0] = table.Name;
 
-                        // Skip all unreal tables other than _Streams.
-                        if (table.Definition.Unreal && "_Streams" != table.Name)
+                        row[1] = columnDef.Name;
+
+                        if (columnDef.Nullable)
                         {
-                            continue;
+                            row[2] = "Y";
+                        }
+                        else
+                        {
+                            row[2] = "N";
                         }
 
-                        // Do not put the _Validation table in patches, it is not needed.
-                        if (OutputType.Patch == this.Output.Type && "_Validation" == table.Name)
+                        if (columnDef.MinValue.HasValue)
                         {
-                            continue;
+                            row[3] = columnDef.MinValue.Value;
                         }
 
-                        // The only way to import binary data is to copy it to a local subdirectory first.
-                        // To avoid this extra copying and perf hit, import an empty table with the same
-                        // definition and later import the binary data from source using records.
-                        foreach (ColumnDefinition columnDefinition in table.Definition.Columns)
+                        if (columnDef.MaxValue.HasValue)
                         {
-                            if (ColumnType.Object == columnDefinition.Type)
-                            {
-                                importTable = new Table(table.Definition);
-                                hasBinaryColumn = true;
-                                break;
-                            }
+                            row[4] = columnDef.MaxValue.Value;
                         }
 
-                        // Create the table via IDT import.
-                        if ("_Streams" != importTable.Name)
+                        row[5] = columnDef.KeyTable;
+
+                        if (columnDef.KeyColumn.HasValue)
                         {
-                            try
-                            {
-                                var command = new CreateIdtFileCommand(this.Messaging, importTable, this.Output.Codepage, idtDirectory, this.KeepAddedColumns);
-                                command.Execute();
+                            row[6] = columnDef.KeyColumn.Value;
+                        }
 
-                                var buildOutput = this.BackendHelper.TrackFile(command.IdtPath, TrackedFileType.Temporary);
-                                this.GeneratedTemporaryFiles.Add(buildOutput);
+                        if (ColumnCategory.Unknown != columnDef.Category)
+                        {
+                            row[7] = columnDef.Category.ToString();
+                        }
 
-                                db.Import(command.IdtPath);
-                            }
-                            catch (WixInvalidIdtException)
-                            {
-                                // If ValidateRows finds anything it doesn't like, it throws
-                                importTable.ValidateRows();
+                        row[8] = columnDef.Possibilities;
 
-                                // Otherwise we rethrow the InvalidIdt
-                                throw;
-                            }
+                        row[9] = columnDef.Description;
+                    }
+                }
+            }
+        }
+
+        private void ImportTables(Database db, string idtDirectory)
+        {
+            foreach (var table in this.Data.Tables)
+            {
+                var importTable = table;
+                var hasBinaryColumn = false;
+
+                // Skip all unreal tables other than _Streams.
+                if (table.Definition.Unreal && "_Streams" != table.Name)
+                {
+                    continue;
+                }
+
+                // Do not put the _Validation table in patches, it is not needed.
+                if (OutputType.Patch == this.Data.Type && "_Validation" == table.Name)
+                {
+                    continue;
+                }
+
+                // The only way to import binary data is to copy it to a local subdirectory first.
+                // To avoid this extra copying and perf hit, import an empty table with the same
+                // definition and later import the binary data from source using records.
+                foreach (var columnDefinition in table.Definition.Columns)
+                {
+                    if (ColumnType.Object == columnDefinition.Type)
+                    {
+                        importTable = new Table(table.Definition);
+                        hasBinaryColumn = true;
+                        break;
+                    }
+                }
+
+                // Create the table via IDT import.
+                if ("_Streams" != importTable.Name)
+                {
+                    try
+                    {
+                        var command = new CreateIdtFileCommand(this.Messaging, importTable, this.Data.Codepage, idtDirectory, this.KeepAddedColumns);
+                        command.Execute();
+
+                        var buildOutput = this.BackendHelper.TrackFile(command.IdtPath, TrackedFileType.Temporary);
+                        this.GeneratedTemporaryFiles.Add(buildOutput);
+
+                        db.Import(command.IdtPath);
+                    }
+                    catch (WixInvalidIdtException)
+                    {
+                        // If ValidateRows finds anything it doesn't like, it throws
+                        importTable.ValidateRows();
+
+                        // Otherwise we rethrow the InvalidIdt
+                        throw;
+                    }
+                }
+
+                // insert the rows via SQL query if this table contains object fields
+                if (hasBinaryColumn)
+                {
+                    var query = new StringBuilder("SELECT ");
+
+                    // Build the query for the view.
+                    var firstColumn = true;
+                    foreach (var columnDefinition in table.Definition.Columns)
+                    {
+                        if (columnDefinition.Unreal)
+                        {
+                            continue;
                         }
 
-                        // insert the rows via SQL query if this table contains object fields
-                        if (hasBinaryColumn)
+                        if (!firstColumn)
                         {
-                            StringBuilder query = new StringBuilder("SELECT ");
+                            query.Append(",");
+                        }
 
-                            // Build the query for the view.
-                            bool firstColumn = true;
-                            foreach (ColumnDefinition columnDefinition in table.Definition.Columns)
+                        query.AppendFormat(" `{0}`", columnDefinition.Name);
+                        firstColumn = false;
+                    }
+                    query.AppendFormat(" FROM `{0}`", table.Name);
+
+                    using (var tableView = db.OpenExecuteView(query.ToString()))
+                    {
+                        // Import each row containing a stream
+                        foreach (var row in table.Rows)
+                        {
+                            using (var record = new Record(table.Definition.Columns.Length))
                             {
-                                if (!firstColumn)
+                                // Stream names are created by concatenating the name of the table with the values
+                                // of the primary key (delimited by periods).
+                                var streamName = new StringBuilder();
+
+                                // the _Streams table doesn't prepend the table name (or a period)
+                                if ("_Streams" != table.Name)
                                 {
-                                    query.Append(",");
+                                    streamName.Append(table.Name);
                                 }
 
-                                query.AppendFormat(" `{0}`", columnDefinition.Name);
-                                firstColumn = false;
-                            }
-                            query.AppendFormat(" FROM `{0}`", table.Name);
+                                var needStream = false;
 
-                            using (View tableView = db.OpenExecuteView(query.ToString()))
-                            {
-                                // Import each row containing a stream
-                                foreach (Row row in table.Rows)
+                                for (var i = 0; i < table.Definition.Columns.Length; i++)
                                 {
-                                    using (Record record = new Record(table.Definition.Columns.Length))
+                                    var columnDefinition = table.Definition.Columns[i];
+
+                                    if (columnDefinition.Unreal)
                                     {
-                                        StringBuilder streamName = new StringBuilder();
-                                        bool needStream = false;
+                                        continue;
+                                    }
+
+                                    switch (columnDefinition.Type)
+                                    {
+                                        case ColumnType.Localized:
+                                        case ColumnType.Preserved:
+                                        case ColumnType.String:
+                                            var str = row.FieldAsString(i);
 
-                                        // the _Streams table doesn't prepend the table name (or a period)
-                                        if ("_Streams" != table.Name)
-                                        {
-                                            streamName.Append(table.Name);
-                                        }
+                                            if (columnDefinition.PrimaryKey)
+                                            {
+                                                if (0 < streamName.Length)
+                                                {
+                                                    streamName.Append(".");
+                                                }
+
+                                                streamName.Append(str);
+                                            }
 
-                                        for (int i = 0; i < table.Definition.Columns.Length; i++)
-                                        {
-                                            ColumnDefinition columnDefinition = table.Definition.Columns[i];
+                                            record.SetString(i + 1, str);
+                                            break;
+                                        case ColumnType.Number:
+                                            record.SetInteger(i + 1, row.FieldAsInteger(i));
+                                            break;
 
-                                            switch (columnDefinition.Type)
+                                        case ColumnType.Object:
+                                            if (null != row[i])
                                             {
-                                                case ColumnType.Localized:
-                                                case ColumnType.Preserved:
-                                                case ColumnType.String:
-                                                    if (columnDefinition.PrimaryKey)
+                                                needStream = true;
+                                                try
+                                                {
+                                                    record.SetStream(i + 1, row.FieldAsString(i));
+                                                }
+                                                catch (Win32Exception e)
+                                                {
+                                                    if (0xA1 == e.NativeErrorCode) // ERROR_BAD_PATHNAME
                                                     {
-                                                        if (0 < streamName.Length)
-                                                        {
-                                                            streamName.Append(".");
-                                                        }
-                                                        streamName.Append((string)row[i]);
+                                                        throw new WixException(ErrorMessages.FileNotFound(row.SourceLineNumbers, row.FieldAsString(i)));
                                                     }
-
-                                                    record.SetString(i + 1, (string)row[i]);
-                                                    break;
-                                                case ColumnType.Number:
-                                                    record.SetInteger(i + 1, Convert.ToInt32(row[i], CultureInfo.InvariantCulture));
-                                                    break;
-                                                case ColumnType.Object:
-                                                    if (null != row[i])
+                                                    else
                                                     {
-                                                        needStream = true;
-                                                        try
-                                                        {
-                                                            record.SetStream(i + 1, (string)row[i]);
-                                                        }
-                                                        catch (Win32Exception e)
-                                                        {
-                                                            if (0xA1 == e.NativeErrorCode) // ERROR_BAD_PATHNAME
-                                                            {
-                                                                throw new WixException(ErrorMessages.FileNotFound(row.SourceLineNumbers, (string)row[i]));
-                                                            }
-                                                            else
-                                                            {
-                                                                throw new WixException(ErrorMessages.Win32Exception(e.NativeErrorCode, e.Message));
-                                                            }
-                                                        }
+                                                        throw new WixException(ErrorMessages.Win32Exception(e.NativeErrorCode, e.Message));
                                                     }
-                                                    break;
+                                                }
                                             }
-                                        }
-
-                                        // stream names are created by concatenating the name of the table with the values
-                                        // of the primary key (delimited by periods)
-                                        // check for a stream name that is more than 62 characters long (the maximum allowed length)
-                                        if (needStream && MsiInterop.MsiMaxStreamNameLength < streamName.Length)
-                                        {
-                                            this.Messaging.Write(ErrorMessages.StreamNameTooLong(row.SourceLineNumbers, table.Name, streamName.ToString(), streamName.Length));
-                                        }
-                                        else // add the row to the database
-                                        {
-                                            tableView.Modify(ModifyView.Assign, record);
-                                        }
+                                            break;
                                     }
                                 }
-                            }
-
-                            // Remove rows from the _Streams table for wixpdbs.
-                            if ("_Streams" == table.Name)
-                            {
-                                table.Rows.Clear();
-                            }
-                        }
-                    }
 
-                    // Insert substorages (usually transforms inside a patch or instance transforms in a package).
-                    if (0 < this.Output.SubStorages.Count)
-                    {
-                        using (View storagesView = new View(db, "SELECT `Name`, `Data` FROM `_Storages`"))
-                        {
-                            foreach (SubStorage subStorage in this.Output.SubStorages)
-                            {
-                                string transformFile = Path.Combine(this.IntermediateFolder, String.Concat(subStorage.Name, ".mst"));
-
-                                // Bind the transform.
-                                this.BindTransform(subStorage.Data, transformFile);
-
-                                if (this.Messaging.EncounteredError)
+                                // check for a stream name that is more than 62 characters long (the maximum allowed length)
+                                if (needStream && MsiInterop.MsiMaxStreamNameLength < streamName.Length)
                                 {
-                                    continue;
+                                    this.Messaging.Write(ErrorMessages.StreamNameTooLong(row.SourceLineNumbers, table.Name, streamName.ToString(), streamName.Length));
                                 }
-
-                                // add the storage
-                                using (Record record = new Record(2))
+                                else // add the row to the database
                                 {
-                                    record.SetString(1, subStorage.Name);
-                                    record.SetStream(2, transformFile);
-                                    storagesView.Modify(ModifyView.Assign, record);
+                                    tableView.Modify(ModifyView.Assign, record);
                                 }
                             }
                         }
                     }
 
-                    // We're good, commit the changes to the new database.
-                    db.Commit();
+                    // Remove rows from the _Streams table for wixpdbs.
+                    if ("_Streams" == table.Name)
+                    {
+                        table.Rows.Clear();
+                    }
                 }
             }
-            catch (IOException e)
-            {
-                // TODO: this error message doesn't seem specific enough
-                throw new WixException(ErrorMessages.FileNotFound(new SourceLineNumber(this.OutputPath), this.OutputPath), e);
-            }
         }
 
-        private void BindTransform(WindowsInstallerData transform, string outputPath)
+        private void ImportSubStorages(Database db)
         {
-            var command = new BindTransformCommand();
-            command.Messaging = this.Messaging;
-            command.Extensions = this.Extensions;
-            command.TempFilesLocation = this.IntermediateFolder;
-            command.Transform = transform;
-            command.OutputPath = outputPath;
-            command.TableDefinitions = this.TableDefinitions;
-            command.Execute();
+            if (0 < this.Data.SubStorages.Count)
+            {
+                using (var storagesView = new View(db, "SELECT `Name`, `Data` FROM `_Storages`"))
+                {
+                    foreach (var subStorage in this.Data.SubStorages)
+                    {
+                        var transformFile = Path.Combine(this.IntermediateFolder, String.Concat(subStorage.Name, ".mst"));
+
+                        // Bind the transform.
+                        var command = new BindTransformCommand(this.Messaging, this.BackendHelper, this.Extensions, this.IntermediateFolder, subStorage.Data, transformFile, this.TableDefinitions);
+                        command.Execute();
+
+                        if (this.Messaging.EncounteredError)
+                        {
+                            continue;
+                        }
+
+                        // Add the storage to the database.
+                        using (var record = new Record(2))
+                        {
+                            record.SetString(1, subStorage.Name);
+                            record.SetStream(2, transformFile);
+                            storagesView.Modify(ModifyView.Assign, record);
+                        }
+                    }
+                }
+            }
         }
 
-        private void SetDatabaseCodepage(Database db, int codepage, string idtDirectory)
+        private void SetDatabaseCodepage(Database db, int codepage, string idtFolder)
         {
-            // write out the _ForceCodepage IDT file
-            var idtPath = Path.Combine(idtDirectory, "_ForceCodepage.idt");
+            // Write out the _ForceCodepage IDT file.
+            var idtPath = Path.Combine(idtFolder, "_ForceCodepage.idt");
             using (var idtFile = new StreamWriter(idtPath, false, Encoding.ASCII))
             {
                 idtFile.WriteLine(); // dummy column name record
@@ -377,14 +406,14 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             var trackId = this.BackendHelper.TrackFile(idtPath, TrackedFileType.Temporary);
             this.GeneratedTemporaryFiles.Add(trackId);
 
-            // try to import the table into the MSI
+            // Try to import the table into the MSI.
             try
             {
                 db.Import(idtPath);
             }
             catch (WixInvalidIdtException)
             {
-                // the IDT should be valid, so an invalid code page was given
+                // The IDT should be valid, so an invalid code page was given.
                 throw new WixException(ErrorMessages.IllegalCodepage(codepage));
             }
         }
diff --git a/src/WixToolset.Core.WindowsInstaller/Bind/GenerateTransformCommand.cs b/src/WixToolset.Core.WindowsInstaller/Bind/GenerateTransformCommand.cs
new file mode 100644
index 00000000..8a7dd702
--- /dev/null
+++ b/src/WixToolset.Core.WindowsInstaller/Bind/GenerateTransformCommand.cs
@@ -0,0 +1,588 @@
+// 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
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using WixToolset.Core.WindowsInstaller.Msi;
+    using WixToolset.Data;
+    using WixToolset.Data.Tuples;
+    using WixToolset.Data.WindowsInstaller;
+    using WixToolset.Data.WindowsInstaller.Rows;
+    using WixToolset.Extensibility;
+    using WixToolset.Extensibility.Services;
+
+    /// <summary>
+    /// Creates a transform by diffing two outputs.
+    /// </summary>
+    public sealed class GenerateTransformCommand
+    {
+        private const char sectionDelimiter = '/';
+        private readonly IMessaging messaging;
+        private SummaryInformationStreams transformSummaryInfo;
+
+        /// <summary>
+        /// Instantiates a new Differ class.
+        /// </summary>
+        public GenerateTransformCommand(IMessaging messaging, WindowsInstallerData targetOutput, WindowsInstallerData updatedOutput, bool showPedanticMessages)
+        {
+            this.messaging = messaging;
+            this.TargetOutput = targetOutput;
+            this.UpdatedOutput = updatedOutput;
+            this.ShowPedanticMessages = showPedanticMessages;
+        }
+
+        private WindowsInstallerData TargetOutput { get; }
+
+        private WindowsInstallerData UpdatedOutput { get; }
+
+        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; }
+
+        /// <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 Execute()
+        {
+            var targetOutput = this.TargetOutput;
+            var updatedOutput = this.UpdatedOutput;
+            var validationFlags = this.ValidationFlags;
+
+            var transform = new WindowsInstallerData(null)
+            {
+                Type = OutputType.Transform,
+                Codepage = updatedOutput.Codepage
+            };
+
+            this.transformSummaryInfo = new SummaryInformationStreams();
+
+            // compare the codepages
+            if (targetOutput.Codepage != updatedOutput.Codepage && 0 == (TransformFlags.ErrorChangeCodePage & validationFlags))
+            {
+                this.messaging.Write(ErrorMessages.OutputCodepageMismatch(targetOutput.SourceLineNumbers, targetOutput.Codepage, updatedOutput.Codepage));
+                if (null != updatedOutput.SourceLineNumbers)
+                {
+                    this.messaging.Write(ErrorMessages.OutputCodepageMismatch2(updatedOutput.SourceLineNumbers));
+                }
+            }
+
+            // compare the output types
+            if (targetOutput.Type != updatedOutput.Type)
+            {
+                throw new WixException(ErrorMessages.OutputTypeMismatch(targetOutput.SourceLineNumbers, targetOutput.Type.ToString(), updatedOutput.Type.ToString()));
+            }
+
+            // compare the contents of the tables
+            foreach (var targetTable in targetOutput.Tables)
+            {
+                var updatedTable = updatedOutput.Tables[targetTable.Name];
+                var operation = TableOperation.None;
+
+                var rows = this.CompareTables(targetOutput, targetTable, updatedTable, out operation);
+
+                if (TableOperation.Drop == operation)
+                {
+                    var droppedTable = transform.EnsureTable(targetTable.Definition);
+                    droppedTable.Operation = TableOperation.Drop;
+                }
+                else if (TableOperation.None == operation)
+                {
+                    var modified = transform.EnsureTable(updatedTable.Definition);
+                    foreach (var row in rows)
+                    {
+                        modified.Rows.Add(row);
+                    }
+                }
+            }
+
+            // added tables
+            foreach (var updatedTable in updatedOutput.Tables)
+            {
+                if (null == targetOutput.Tables[updatedTable.Name])
+                {
+                    var addedTable = transform.EnsureTable(updatedTable.Definition);
+                    addedTable.Operation = TableOperation.Add;
+
+                    foreach (var updatedRow in updatedTable.Rows)
+                    {
+                        updatedRow.Operation = RowOperation.Add;
+                        updatedRow.SectionId = sectionDelimiter + updatedRow.SectionId;
+                        addedTable.Rows.Add(updatedRow);
+                    }
+                }
+            }
+
+            // set summary information properties
+            if (!this.SuppressKeepingSpecialRows)
+            {
+                var summaryInfoTable = transform.Tables["_SummaryInformation"];
+                this.UpdateTransformSummaryInformationTable(summaryInfoTable, validationFlags);
+            }
+
+            this.Transform = transform;
+            return this.Transform;
+        }
+
+        /// <summary>
+        /// Add a row to the <paramref name="index"/> using the primary key.
+        /// </summary>
+        /// <param name="index">The indexed rows.</param>
+        /// <param name="row">The row to index.</param>
+        private void AddIndexedRow(Dictionary<string, Row> index, Row row)
+        {
+            var primaryKey = row.GetPrimaryKey();
+
+            if (null != primaryKey)
+            {
+                if (index.TryGetValue(primaryKey, out var collisionRow))
+                {
+                    // 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;
+                    }
+
+                    if (this.ShowPedanticMessages)
+                    {
+                        this.messaging.Write(ErrorMessages.DuplicatePrimaryKey(row.SourceLineNumbers, primaryKey, row.Table.Name));
+                    }
+                }
+                else
+                {
+                    index.Add(primaryKey, row);
+                }
+            }
+            else // use the string representation of the row as its primary key (it may not be unique)
+            {
+                // this is provided for compatibility with unreal tables with no primary key
+                // all real tables must specify at least one column as the primary key
+                primaryKey = row.ToString();
+                index[primaryKey] = row;
+            }
+        }
+
+        private bool CompareRows(Table targetTable, Row targetRow, Row updatedRow, out Row comparedRow)
+        {
+            comparedRow = null;
+
+            var keepRow = false;
+
+            if (null == targetRow ^ null == updatedRow)
+            {
+                if (null == targetRow)
+                {
+                    updatedRow.Operation = RowOperation.Add;
+                    comparedRow = updatedRow;
+                }
+                else if (null == updatedRow)
+                {
+                    targetRow.Operation = RowOperation.Delete;
+                    targetRow.SectionId += sectionDelimiter;
+
+                    comparedRow = targetRow;
+                    keepRow = true;
+                }
+            }
+            else // possibly modified
+            {
+                updatedRow.Operation = RowOperation.None;
+                if (!this.SuppressKeepingSpecialRows && "_SummaryInformation" == targetTable.Name)
+                {
+                    // 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;
+                        comparedRow = updatedRow;
+                        keepRow = true;
+                    }
+                }
+                else
+                {
+                    if (this.PreserveUnchangedRows)
+                    {
+                        keepRow = true;
+                    }
+
+                    for (var i = 0; i < updatedRow.Fields.Length; i++)
+                    {
+                        var columnDefinition = updatedRow.Fields[i].Column;
+
+                        if (columnDefinition.Unreal)
+                        {
+                        }
+                        else if (!columnDefinition.PrimaryKey)
+                        {
+                            var modified = false;
+
+                            if (i >= targetRow.Fields.Length)
+                            {
+                                columnDefinition.Added = true;
+                                modified = true;
+                            }
+                            else if (ColumnType.Number == columnDefinition.Type && !columnDefinition.IsLocalizable)
+                            {
+                                if (null == targetRow[i] ^ null == updatedRow[i])
+                                {
+                                    modified = true;
+                                }
+                                else if (null != targetRow[i] && null != updatedRow[i])
+                                {
+                                    modified = (targetRow.FieldAsInteger(i) != updatedRow.FieldAsInteger(i));
+                                }
+                            }
+                            else if (ColumnType.Preserved == columnDefinition.Type)
+                            {
+                                updatedRow.Fields[i].PreviousData = targetRow.FieldAsString(i);
+
+                                // keep rows containing preserved fields so the historical data is available to the binder
+                                keepRow = !this.SuppressKeepingSpecialRows;
+                            }
+                            else if (ColumnType.Object == columnDefinition.Type)
+                            {
+                                var targetObjectField = (ObjectField)targetRow.Fields[i];
+                                var updatedObjectField = (ObjectField)updatedRow.Fields[i];
+
+                                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
+                                updatedObjectField.PreviousData = (string)targetObjectField.Data;
+
+                                // 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
+                                keepRow = !this.SuppressKeepingSpecialRows;
+                            }
+                            else
+                            {
+                                modified = (targetRow.FieldAsString(i) != updatedRow.FieldAsString(i));
+                            }
+
+                            if (modified)
+                            {
+                                if (null != updatedRow.Fields[i].PreviousData)
+                                {
+                                    updatedRow.Fields[i].PreviousData = targetRow.FieldAsString(i);
+                                }
+
+                                updatedRow.Fields[i].Modified = true;
+                                updatedRow.Operation = RowOperation.Modify;
+                                keepRow = true;
+                            }
+                        }
+                    }
+
+                    if (keepRow)
+                    {
+                        comparedRow = updatedRow;
+                        comparedRow.SectionId = targetRow.SectionId + sectionDelimiter + updatedRow.SectionId;
+                    }
+                }
+            }
+
+            return keepRow;
+        }
+
+        private List<Row> CompareTables(WindowsInstallerData targetOutput, Table targetTable, Table updatedTable, out TableOperation operation)
+        {
+            var rows = new List<Row>();
+            operation = TableOperation.None;
+
+            // dropped tables
+            if (null == updatedTable ^ null == targetTable)
+            {
+                if (null == targetTable)
+                {
+                    operation = TableOperation.Add;
+                    rows.AddRange(updatedTable.Rows);
+                }
+                else if (null == updatedTable)
+                {
+                    operation = TableOperation.Drop;
+                }
+            }
+            else // possibly modified tables
+            {
+                var updatedPrimaryKeys = new Dictionary<string, Row>();
+                var targetPrimaryKeys = new Dictionary<string, Row>();
+
+                // compare the table definitions
+                if (0 != targetTable.Definition.CompareTo(updatedTable.Definition))
+                {
+                    // continue to the next table; may be more mismatches
+                    this.messaging.Write(ErrorMessages.DatabaseSchemaMismatch(targetOutput.SourceLineNumbers, targetTable.Name));
+                }
+                else
+                {
+                    this.IndexPrimaryKeys(targetTable, targetPrimaryKeys, updatedTable, updatedPrimaryKeys);
+
+                    // diff the target and updated rows
+                    foreach (var targetPrimaryKeyEntry in targetPrimaryKeys)
+                    {
+                        var targetPrimaryKey = targetPrimaryKeyEntry.Key;
+                        var targetRow = targetPrimaryKeyEntry.Value;
+                        updatedPrimaryKeys.TryGetValue(targetPrimaryKey, out var updatedRow);
+
+                        var keepRow = this.CompareRows(targetTable, targetRow, updatedRow, out var compared);
+
+                        if (keepRow)
+                        {
+                            rows.Add(compared);
+                        }
+                    }
+
+                    // find the inserted rows
+                    foreach (var updatedPrimaryKeyEntry in updatedPrimaryKeys)
+                    {
+                        var updatedPrimaryKey = updatedPrimaryKeyEntry.Key;
+
+                        if (!targetPrimaryKeys.ContainsKey(updatedPrimaryKey))
+                        {
+                            var updatedRow = updatedPrimaryKeyEntry.Value;
+
+                            updatedRow.Operation = RowOperation.Add;
+                            updatedRow.SectionId = sectionDelimiter + updatedRow.SectionId;
+                            rows.Add(updatedRow);
+                        }
+                    }
+                }
+            }
+
+            return rows;
+        }
+
+        private void IndexPrimaryKeys(Table targetTable, Dictionary<string, Row> targetPrimaryKeys, Table updatedTable, Dictionary<string, Row> updatedPrimaryKeys)
+        {
+            // index the target rows
+            foreach (var row in targetTable.Rows)
+            {
+                this.AddIndexedRow(targetPrimaryKeys, row);
+
+                if ("Property" == targetTable.Name)
+                {
+                    var id = row.FieldAsString(0);
+
+                    if ("ProductCode" == id)
+                    {
+                        this.transformSummaryInfo.TargetProductCode = row.FieldAsString(1);
+
+                        if ("*" == this.transformSummaryInfo.TargetProductCode)
+                        {
+                            this.messaging.Write(ErrorMessages.ProductCodeInvalidForTransform(row.SourceLineNumbers));
+                        }
+                    }
+                    else if ("ProductVersion" == id)
+                    {
+                        this.transformSummaryInfo.TargetProductVersion = row.FieldAsString(1);
+                    }
+                    else if ("UpgradeCode" == id)
+                    {
+                        this.transformSummaryInfo.TargetUpgradeCode = row.FieldAsString(1);
+                    }
+                }
+                else if ("_SummaryInformation" == targetTable.Name)
+                {
+                    var id = row.FieldAsInteger(0);
+
+                    if (1 == id) // PID_CODEPAGE
+                    {
+                        this.transformSummaryInfo.TargetSummaryInfoCodepage = row.FieldAsString(1);
+                    }
+                    else if (7 == id) // PID_TEMPLATE
+                    {
+                        this.transformSummaryInfo.TargetPlatformAndLanguage = row.FieldAsString(1);
+                    }
+                    else if (14 == id) // PID_PAGECOUNT
+                    {
+                        this.transformSummaryInfo.TargetMinimumVersion = row.FieldAsString(1);
+                    }
+                }
+            }
+
+            // index the updated rows
+            foreach (var row in updatedTable.Rows)
+            {
+                this.AddIndexedRow(updatedPrimaryKeys, row);
+
+                if ("Property" == updatedTable.Name)
+                {
+                    var id = row.FieldAsString(0);
+
+                    if ("ProductCode" == id)
+                    {
+                        this.transformSummaryInfo.UpdatedProductCode = row.FieldAsString(1);
+
+                        if ("*" == this.transformSummaryInfo.UpdatedProductCode)
+                        {
+                            this.messaging.Write(ErrorMessages.ProductCodeInvalidForTransform(row.SourceLineNumbers));
+                        }
+                    }
+                    else if ("ProductVersion" == id)
+                    {
+                        this.transformSummaryInfo.UpdatedProductVersion = row.FieldAsString(1);
+                    }
+                }
+                else if ("_SummaryInformation" == updatedTable.Name)
+                {
+                    var id = row.FieldAsInteger(0);
+
+                    if (1 == id) // PID_CODEPAGE
+                    {
+                        this.transformSummaryInfo.UpdatedSummaryInfoCodepage = row.FieldAsString(1);
+                    }
+                    else if (7 == id) // PID_TEMPLATE
+                    {
+                        this.transformSummaryInfo.UpdatedPlatformAndLanguage = row.FieldAsString(1);
+                    }
+                    else if (14 == id) // PID_PAGECOUNT
+                    {
+                        this.transformSummaryInfo.UpdatedMinimumVersion = row.FieldAsString(1);
+                    }
+                }
+            }
+        }
+
+        private void UpdateTransformSummaryInformationTable(Table summaryInfoTable, TransformFlags validationFlags)
+        {
+            // calculate the minimum version of MSI required to process the transform
+            var minimumVersion = 100;
+
+            if (Int32.TryParse(this.transformSummaryInfo.TargetMinimumVersion, out var targetMin) && Int32.TryParse(this.transformSummaryInfo.UpdatedMinimumVersion, out var updatedMin))
+            {
+                minimumVersion = Math.Max(targetMin, updatedMin);
+            }
+
+            var summaryRows = new Dictionary<int, Row>(summaryInfoTable.Rows.Count);
+
+            foreach (var row in summaryInfoTable.Rows)
+            {
+                var id = row.FieldAsInteger(0);
+
+                summaryRows[id] = row;
+
+                if ((int)SummaryInformation.Transform.CodePage == id)
+                {
+                    row.Fields[1].Data = this.transformSummaryInfo.UpdatedSummaryInfoCodepage;
+                    row.Fields[1].PreviousData = this.transformSummaryInfo.TargetSummaryInfoCodepage;
+                }
+                else if ((int)SummaryInformation.Transform.TargetPlatformAndLanguage == id)
+                {
+                    row[1] = this.transformSummaryInfo.TargetPlatformAndLanguage;
+                }
+                else if ((int)SummaryInformation.Transform.UpdatedPlatformAndLanguage == id)
+                {
+                    row[1] = this.transformSummaryInfo.UpdatedPlatformAndLanguage;
+                }
+                else if ((int)SummaryInformation.Transform.ProductCodes == id)
+                {
+                    row[1] = String.Concat(this.transformSummaryInfo.TargetProductCode, this.transformSummaryInfo.TargetProductVersion, ';', this.transformSummaryInfo.UpdatedProductCode, this.transformSummaryInfo.UpdatedProductVersion, ';', this.transformSummaryInfo.TargetUpgradeCode);
+                }
+                else if ((int)SummaryInformation.Transform.InstallerRequirement == id)
+                {
+                    row[1] = minimumVersion.ToString(CultureInfo.InvariantCulture);
+                }
+                else if ((int)SummaryInformation.Transform.Security == id)
+                {
+                    row[1] = "4";
+                }
+            }
+
+            if (!summaryRows.ContainsKey((int)SummaryInformation.Transform.TargetPlatformAndLanguage))
+            {
+                var summaryRow = summaryInfoTable.CreateRow(null);
+                summaryRow[0] = (int)SummaryInformation.Transform.TargetPlatformAndLanguage;
+                summaryRow[1] = this.transformSummaryInfo.TargetPlatformAndLanguage;
+            }
+
+            if (!summaryRows.ContainsKey((int)SummaryInformation.Transform.UpdatedPlatformAndLanguage))
+            {
+                var summaryRow = summaryInfoTable.CreateRow(null);
+                summaryRow[0] = (int)SummaryInformation.Transform.UpdatedPlatformAndLanguage;
+                summaryRow[1] = this.transformSummaryInfo.UpdatedPlatformAndLanguage;
+            }
+
+            if (!summaryRows.ContainsKey((int)SummaryInformation.Transform.ValidationFlags))
+            {
+                var summaryRow = summaryInfoTable.CreateRow(null);
+                summaryRow[0] = (int)SummaryInformation.Transform.ValidationFlags;
+                summaryRow[1] = ((int)validationFlags).ToString(CultureInfo.InvariantCulture);
+            }
+
+            if (!summaryRows.ContainsKey((int)SummaryInformation.Transform.InstallerRequirement))
+            {
+                var summaryRow = summaryInfoTable.CreateRow(null);
+                summaryRow[0] = (int)SummaryInformation.Transform.InstallerRequirement;
+                summaryRow[1] = minimumVersion.ToString(CultureInfo.InvariantCulture);
+            }
+
+            if (!summaryRows.ContainsKey((int)SummaryInformation.Transform.Security))
+            {
+                var summaryRow = summaryInfoTable.CreateRow(null);
+                summaryRow[0] = (int)SummaryInformation.Transform.Security;
+                summaryRow[1] = "4";
+            }
+        }
+
+        private class SummaryInformationStreams
+        {
+            public string TargetSummaryInfoCodepage { get; set; }
+
+            public string TargetPlatformAndLanguage { get; set; }
+
+            public string TargetProductCode { get; set; }
+
+            public string TargetProductVersion { get; set; }
+
+            public string TargetUpgradeCode { get; set; }
+
+            public string TargetMinimumVersion { get; set; }
+
+            public string UpdatedSummaryInfoCodepage { get; set; }
+
+            public string UpdatedPlatformAndLanguage { get; set; }
+
+            public string UpdatedProductCode { get; set; }
+
+            public string UpdatedProductVersion { get; set; }
+
+            public string UpdatedMinimumVersion { get; set; }
+        }
+    }
+}
diff --git a/src/WixToolset.Core.WindowsInstaller/Bind/GetFileFacadesCommand.cs b/src/WixToolset.Core.WindowsInstaller/Bind/GetFileFacadesCommand.cs
index 0da6a6b0..2844f797 100644
--- a/src/WixToolset.Core.WindowsInstaller/Bind/GetFileFacadesCommand.cs
+++ b/src/WixToolset.Core.WindowsInstaller/Bind/GetFileFacadesCommand.cs
@@ -132,7 +132,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                 file.SymbolPaths = String.Concat(file.SymbolPaths, ";", row.SymbolPaths);
             }
 
-#if REVISIT_FOR_PATCHING
+#if TODO_PATCHING
             Field field = row.Fields[2];
             if (null != field.PreviousData)
             {
diff --git a/src/WixToolset.Core.WindowsInstaller/Bind/GetFileFacadesFromTransforms.cs b/src/WixToolset.Core.WindowsInstaller/Bind/GetFileFacadesFromTransforms.cs
new file mode 100644
index 00000000..9818f01a
--- /dev/null
+++ b/src/WixToolset.Core.WindowsInstaller/Bind/GetFileFacadesFromTransforms.cs
@@ -0,0 +1,585 @@
+// 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.Collections.Generic;
+    using System.Diagnostics;
+    using System.IO;
+    using System.Linq;
+    using WixToolset.Core.Bind;
+    using WixToolset.Data;
+    using WixToolset.Data.Tuples;
+    using WixToolset.Data.WindowsInstaller;
+    using WixToolset.Data.WindowsInstaller.Rows;
+    using WixToolset.Extensibility;
+    using WixToolset.Extensibility.Services;
+
+    internal class GetFileFacadesFromTransforms
+    {
+        public GetFileFacadesFromTransforms(IMessaging messaging, IEnumerable<SubStorage> subStorages, TableDefinitionCollection tableDefinitions)
+        {
+            this.Messaging = messaging;
+            this.SubStorages = subStorages;
+            this.TableDefinitions = tableDefinitions;
+        }
+
+        public IEnumerable<IFileSystemExtension> Extensions { get; }
+
+        private IMessaging Messaging { get; }
+
+        public IEnumerable<SubStorage> SubStorages { get; }
+
+        private TableDefinitionCollection TableDefinitions { get; }
+
+        public IEnumerable<FileFacade> FileFacades { get; private set; }
+
+        public void Execute()
+        {
+            var allFileRows = new List<FileFacade>();
+            var copyToPatch = (allFileRows != null);
+#if TODO_PATCHING
+            var patchMediaRows = new RowDictionary<MediaRow>();
+
+            var patchMediaFileRows = new Dictionary<int, RowDictionary<WixFileRow>>();
+
+            var patchActualFileTable = this.Output.EnsureTable(this.TableDefinitions["File"]);
+            var patchFileTable = this.Output.EnsureTable(this.TableDefinitions["WixFile"]);
+
+            if (copyFromPatch)
+            {
+                // index patch files by diskId+fileId
+                foreach (WixFileRow patchFileRow in patchFileTable.Rows)
+                {
+                    int diskId = patchFileRow.DiskId;
+                    if (!patchMediaFileRows.TryGetValue(diskId, out var mediaFileRows))
+                    {
+                        mediaFileRows = new RowDictionary<WixFileRow>();
+                        patchMediaFileRows.Add(diskId, mediaFileRows);
+                    }
+
+                    mediaFileRows.Add(patchFileRow);
+                }
+
+                var patchMediaTable = this.Output.EnsureTable(this.TableDefinitions["Media"]);
+                patchMediaRows = new RowDictionary<MediaRow>(patchMediaTable);
+            }
+
+            // Index paired transforms by name without their "#" prefix.
+            var pairedTransforms = this.SubStorages.Where(s => s.Name.StartsWith("#")).ToDictionary(s => s.Name.Substring(1), s => s.Data);
+
+            foreach (var substorage in this.SubStorages)
+            {
+                if (substorage.Name.StartsWith("#"))
+                {
+                    // Skip paired transforms.
+                    continue;
+                }
+
+                var mainTransform = substorage.Data;
+                var mainWixFiles = new RowDictionary<WixFileRow>(mainTransform.Tables["WixFile"]);
+                var mainMsiFileHashIndex = new RowDictionary<Row>(mainTransform.Tables["MsiFileHash"]);
+
+                var mainFileTable = mainTransform.Tables["File"];
+                var pairedTransform = pairedTransforms[substorage.Name];
+
+                // copy Media.LastSequence and index the MsiFileHash table if it exists.
+                if (copyFromPatch)
+                {
+                    var pairedMediaTable = pairedTransform.Tables["Media"];
+                    foreach (MediaRow pairedMediaRow in pairedMediaTable.Rows)
+                    {
+                        var patchMediaRow = patchMediaRows.Get(pairedMediaRow.DiskId);
+                        pairedMediaRow.Fields[1] = patchMediaRow.Fields[1];
+                    }
+
+                    if (null != mainMsiFileHashTable)
+                    {
+                        mainMsiFileHashIndex = new RowDictionary<Row>(mainMsiFileHashTable);
+                    }
+
+                    // Validate file row changes for keypath-related issues
+                    this.ValidateFileRowChanges(mainTransform);
+                }
+
+                if (null == mainFileTable)
+                {
+                    continue;
+                }
+
+                // Index File table of pairedTransform
+                var pairedFileRows = new RowDictionary<FileRow>(pairedTransform.Tables["File"]);
+
+                foreach (FileRow mainFileRow in mainFileTable.Rows)
+                {
+                    if (RowOperation.Delete == mainFileRow.Operation)
+                    {
+                        continue;
+                    }
+                    else if (RowOperation.None == mainFileRow.Operation)
+                    {
+                        continue;
+                    }
+
+                    var mainWixFileRow = mainWixFiles.Get(mainFileRow.File);
+
+                    if (copyToPatch) // when copying to the patch, we need compare the underlying files and include all file changes.
+                    {
+                        var objectField = (ObjectField)mainWixFileRow.Fields[6];
+                        var pairedFileRow = pairedFileRows.Get(mainFileRow.File);
+
+                        // If the file is new, we always need to add it to the patch.
+                        if (mainFileRow.Operation != RowOperation.Add)
+                        {
+                            // If PreviousData doesn't exist, target and upgrade layout point to the same location. No need to compare.
+                            if (null == objectField.PreviousData)
+                            {
+                                if (mainFileRow.Operation == RowOperation.None)
+                                {
+                                    continue;
+                                }
+                            }
+                            else
+                            {
+                                // TODO: should this entire condition be placed in the binder file manager?
+                                if ((0 == (PatchAttributeType.Ignore & mainWixFileRow.PatchAttributes)) &&
+                                    !this.CompareFiles(objectField.PreviousData.ToString(), objectField.Data.ToString()))
+                                {
+                                    // If the file is different, we need to mark the mainFileRow and pairedFileRow as modified.
+                                    mainFileRow.Operation = RowOperation.Modify;
+                                    if (null != pairedFileRow)
+                                    {
+                                        // Always patch-added, but never non-compressed.
+                                        pairedFileRow.Attributes |= WindowsInstallerConstants.MsidbFileAttributesPatchAdded;
+                                        pairedFileRow.Attributes &= ~WindowsInstallerConstants.MsidbFileAttributesNoncompressed;
+                                        pairedFileRow.Fields[6].Modified = true;
+                                        pairedFileRow.Operation = RowOperation.Modify;
+                                    }
+                                }
+                                else
+                                {
+                                    // The File is same. We need mark all the attributes as unchanged.
+                                    mainFileRow.Operation = RowOperation.None;
+                                    foreach (var field in mainFileRow.Fields)
+                                    {
+                                        field.Modified = false;
+                                    }
+
+                                    if (null != pairedFileRow)
+                                    {
+                                        pairedFileRow.Attributes &= ~WindowsInstallerConstants.MsidbFileAttributesPatchAdded;
+                                        pairedFileRow.Fields[6].Modified = false;
+                                        pairedFileRow.Operation = RowOperation.None;
+                                    }
+                                    continue;
+                                }
+                            }
+                        }
+                        else if (null != pairedFileRow) // RowOperation.Add
+                        {
+                            // Always patch-added, but never non-compressed.
+                            pairedFileRow.Attributes |= WindowsInstallerConstants.MsidbFileAttributesPatchAdded;
+                            pairedFileRow.Attributes &= ~WindowsInstallerConstants.MsidbFileAttributesNoncompressed;
+                            pairedFileRow.Fields[6].Modified = true;
+                            pairedFileRow.Operation = RowOperation.Add;
+                        }
+                    }
+
+                    // index patch files by diskId+fileId
+                    int diskId = mainWixFileRow.DiskId;
+
+                    if (!patchMediaFileRows.TryGetValue(diskId, out var mediaFileRows))
+                    {
+                        mediaFileRows = new RowDictionary<WixFileRow>();
+                        patchMediaFileRows.Add(diskId, mediaFileRows);
+                    }
+
+                    var fileId = mainFileRow.File;
+                    var patchFileRow = mediaFileRows.Get(fileId);
+                    if (copyToPatch)
+                    {
+                        if (null == patchFileRow)
+                        {
+                            var patchActualFileRow = (FileRow)patchFileTable.CreateRow(mainFileRow.SourceLineNumbers);
+                            patchActualFileRow.CopyFrom(mainFileRow);
+
+                            patchFileRow = (WixFileRow)patchFileTable.CreateRow(mainFileRow.SourceLineNumbers);
+                            patchFileRow.CopyFrom(mainWixFileRow);
+
+                            mediaFileRows.Add(patchFileRow);
+
+                            allFileRows.Add(new FileFacade(patchActualFileRow, patchFileRow, null)); // TODO: should we be passing along delta information? Probably, right?
+                        }
+                        else
+                        {
+                            // TODO: confirm the rest of data is identical?
+
+                            // make sure Source is same. Otherwise we are silently ignoring a file.
+                            if (0 != String.Compare(patchFileRow.Source, mainWixFileRow.Source, StringComparison.OrdinalIgnoreCase))
+                            {
+                                this.Messaging.Write(ErrorMessages.SameFileIdDifferentSource(mainFileRow.SourceLineNumbers, fileId, patchFileRow.Source, mainWixFileRow.Source));
+                            }
+
+                            // capture the previous file versions (and associated data) from this targeted instance of the baseline into the current filerow.
+                            patchFileRow.AppendPreviousDataFrom(mainWixFileRow);
+                        }
+                    }
+                    //else
+                    //{
+                    //    // copy data from the patch back to the transform
+                    //    if (null != patchFileRow)
+                    //    {
+                    //        var pairedFileRow = pairedFileRows.Get(fileId);
+                    //        for (var i = 0; i < patchFileRow.Fields.Length; i++)
+                    //        {
+                    //            var patchValue = patchFileRow[i] == null ? String.Empty : patchFileRow.FieldAsString(i);
+                    //            var mainValue = mainFileRow[i] == null ? String.Empty : mainFileRow.FieldAsString(i);
+
+                    //            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).
+                    //            }
+                    //            // File.Attributes should not changed for binary deltas
+                    //            else if (6 == i)
+                    //            {
+                    //                if (null != patchFileRow.Patch)
+                    //                {
+                    //                    // File.Attribute should not change for binary deltas
+                    //                    pairedFileRow.Attributes = mainFileRow.Attributes;
+                    //                    mainFileRow.Fields[i].Modified = false;
+                    //                }
+                    //            }
+                    //            // File.Sequence is updated in pairedTransform, not mainTransform
+                    //            else if (7 == i)
+                    //            {
+                    //                // file sequence is updated in Patch table instead of File table for delta patches
+                    //                if (null != patchFileRow.Patch)
+                    //                {
+                    //                    pairedFileRow.Fields[i].Modified = false;
+                    //                }
+                    //                else
+                    //                {
+                    //                    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;
+                    //                }
+                    //            }
+                    //        }
+
+                    //        // copy MsiFileHash row for this File
+                    //        if (!mainMsiFileHashIndex.TryGetValue(patchFileRow.File, out var patchHashRow))
+                    //        {
+                    //            patchHashRow = patchFileRow.Hash;
+                    //        }
+
+                    //        if (null != patchHashRow)
+                    //        {
+                    //            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;
+                    //        }
+
+                    //        // copy MsiAssemblyName rows for this File
+                    //        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;
+                    //                    }
+                    //                }
+
+                    //                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;
+                    //                }
+                    //            }
+                    //        }
+
+                    //        // Add patch header for this file
+                    //        if (null != patchFileRow.Patch)
+                    //        {
+                    //            // Add the PatchFiles action automatically to the AdminExecuteSequence and InstallExecuteSequence tables.
+                    //            this.AddPatchFilesActionToSequenceTable(SequenceTable.AdminExecuteSequence, mainTransform, pairedTransform, mainFileRow);
+                    //            this.AddPatchFilesActionToSequenceTable(SequenceTable.InstallExecuteSequence, mainTransform, pairedTransform, mainFileRow);
+
+                    //            // Add to Patch table
+                    //            var patchTable = pairedTransform.EnsureTable(this.TableDefinitions["Patch"]);
+                    //            if (0 == patchTable.Rows.Count)
+                    //            {
+                    //                patchTable.Operation = TableOperation.Add;
+                    //            }
+
+                    //            var patchRow = patchTable.CreateRow(mainFileRow.SourceLineNumbers);
+                    //            patchRow[0] = patchFileRow.File;
+                    //            patchRow[1] = patchFileRow.Sequence;
+
+                    //            var patchFile = new FileInfo(patchFileRow.Source);
+                    //            patchRow[2] = (int)patchFile.Length;
+                    //            patchRow[3] = 0 == (PatchAttributeType.AllowIgnoreOnError & patchFileRow.PatchAttributes) ? 0 : 1;
+
+                    //            var streamName = patchTable.Name + "." + patchRow[0] + "." + patchRow[1];
+                    //            if (Msi.MsiInterop.MsiMaxStreamNameLength < streamName.Length)
+                    //            {
+                    //                streamName = "_" + Guid.NewGuid().ToString("D").ToUpperInvariant().Replace('-', '_');
+
+                    //                var patchHeadersTable = pairedTransform.EnsureTable(this.TableDefinitions["MsiPatchHeaders"]);
+                    //                if (0 == patchHeadersTable.Rows.Count)
+                    //                {
+                    //                    patchHeadersTable.Operation = TableOperation.Add;
+                    //                }
+
+                    //                var patchHeadersRow = patchHeadersTable.CreateRow(mainFileRow.SourceLineNumbers);
+                    //                patchHeadersRow[0] = streamName;
+                    //                patchHeadersRow[1] = patchFileRow.Patch;
+                    //                patchRow[5] = streamName;
+                    //                patchHeadersRow.Operation = RowOperation.Add;
+                    //            }
+                    //            else
+                    //            {
+                    //                patchRow[4] = patchFileRow.Patch;
+                    //            }
+                    //            patchRow.Operation = RowOperation.Add;
+                    //        }
+                    //    }
+                    //    else
+                    //    {
+                    //        // TODO: throw because all transform rows should have made it into the patch
+                    //    }
+                    //}
+                }
+            }
+#endif
+            this.FileFacades = allFileRows;
+        }
+
+        /// <summary>
+        /// Adds the PatchFiles action to the sequence table if it does not already exist.
+        /// </summary>
+        /// <param name="table">The sequence table to check or modify.</param>
+        /// <param name="mainTransform">The primary authoring transform.</param>
+        /// <param name="pairedTransform">The secondary patch transform.</param>
+        /// <param name="mainFileRow">The file row that contains information about the patched file.</param>
+        private void AddPatchFilesActionToSequenceTable(SequenceTable table, WindowsInstallerData mainTransform, WindowsInstallerData pairedTransform, Row mainFileRow)
+        {
+            var tableName = table.ToString();
+
+            // Find/add PatchFiles action (also determine sequence for it).
+            // Search mainTransform first, then pairedTransform (pairedTransform overrides).
+            var hasPatchFilesAction = false;
+            var installFilesSequence = 0;
+            var duplicateFilesSequence = 0;
+
+            TestSequenceTableForPatchFilesAction(
+                    mainTransform.Tables[tableName],
+                    ref hasPatchFilesAction,
+                    ref installFilesSequence,
+                    ref duplicateFilesSequence);
+            TestSequenceTableForPatchFilesAction(
+                    pairedTransform.Tables[tableName],
+                    ref hasPatchFilesAction,
+                    ref installFilesSequence,
+                    ref duplicateFilesSequence);
+            if (!hasPatchFilesAction)
+            {
+                WindowsInstallerStandard.TryGetStandardAction(tableName, "PatchFiles", out var patchFilesActionTuple);
+
+                var sequence = patchFilesActionTuple.Sequence;
+
+                // Test for default sequence value's appropriateness
+                if (installFilesSequence >= sequence || (0 != duplicateFilesSequence && duplicateFilesSequence <= sequence))
+                {
+                    if (0 != duplicateFilesSequence)
+                    {
+                        if (duplicateFilesSequence < installFilesSequence)
+                        {
+                            throw new WixException(ErrorMessages.InsertInvalidSequenceActionOrder(mainFileRow.SourceLineNumbers, tableName, "InstallFiles", "DuplicateFiles", patchFilesActionTuple.Action));
+                        }
+                        else
+                        {
+                            sequence = (duplicateFilesSequence + installFilesSequence) / 2;
+                            if (installFilesSequence == sequence || duplicateFilesSequence == sequence)
+                            {
+                                throw new WixException(ErrorMessages.InsertSequenceNoSpace(mainFileRow.SourceLineNumbers, tableName, "InstallFiles", "DuplicateFiles", patchFilesActionTuple.Action));
+                            }
+                        }
+                    }
+                    else
+                    {
+                        sequence = installFilesSequence + 1;
+                    }
+                }
+
+                var sequenceTable = pairedTransform.EnsureTable(this.TableDefinitions[tableName]);
+                if (0 == sequenceTable.Rows.Count)
+                {
+                    sequenceTable.Operation = TableOperation.Add;
+                }
+
+                var patchAction = sequenceTable.CreateRow(null);
+                patchAction[0] = patchFilesActionTuple.Action;
+                patchAction[1] = patchFilesActionTuple.Condition;
+                patchAction[2] = sequence;
+                patchAction.Operation = RowOperation.Add;
+            }
+        }
+
+        /// <summary>
+        /// Tests sequence table for PatchFiles and associated actions
+        /// </summary>
+        /// <param name="sequenceTable">The table to test.</param>
+        /// <param name="hasPatchFilesAction">Set to true if PatchFiles action is found. Left unchanged otherwise.</param>
+        /// <param name="installFilesSequence">Set to sequence value of InstallFiles action if found. Left unchanged otherwise.</param>
+        /// <param name="duplicateFilesSequence">Set to sequence value of DuplicateFiles action if found. Left unchanged otherwise.</param>
+        private static void TestSequenceTableForPatchFilesAction(Table sequenceTable, ref bool hasPatchFilesAction, ref int installFilesSequence, ref int duplicateFilesSequence)
+        {
+            if (null != sequenceTable)
+            {
+                foreach (var row in sequenceTable.Rows)
+                {
+                    var actionName = row.FieldAsString(0);
+                    switch (actionName)
+                    {
+                        case "PatchFiles":
+                            hasPatchFilesAction = true;
+                            break;
+
+                        case "InstallFiles":
+                            installFilesSequence = row.FieldAsInteger(2);
+                            break;
+
+                        case "DuplicateFiles":
+                            duplicateFilesSequence = row.FieldAsInteger(2);
+                            break;
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Signal a warning if a non-keypath file was changed in a patch without also changing the keypath file of the component.
+        /// </summary>
+        /// <param name="output">The output to validate.</param>
+        private void ValidateFileRowChanges(WindowsInstallerData transform)
+        {
+            var componentTable = transform.Tables["Component"];
+            var fileTable = transform.Tables["File"];
+
+            // There's no sense validating keypaths if the transform has no component or file table
+            if (componentTable == null || fileTable == null)
+            {
+                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 keyPath = row.FieldAsString(5);
+                if (keyPath != null && 0 != (row.FieldAsInteger(3) & WindowsInstallerConstants.MsidbComponentAttributesRegistryKeyPath))
+                {
+                    componentKeyPath.Add(row.FieldAsString(0), 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)
+            {
+                if (RowOperation.Modify != row.Operation)
+                {
+                    continue;
+                }
+
+                var fileId = row.FieldAsString(0);
+                var componentId = row.FieldAsString(1);
+
+                // If this file is the keypath of a component
+                if (componentKeyPath.ContainsValue(fileId))
+                {
+                    if (!componentWithChangedKeyPath.ContainsKey(componentId))
+                    {
+                        componentWithChangedKeyPath.Add(componentId, fileId);
+                    }
+                }
+                else
+                {
+                    if (!componentWithNonKeyPathChanged.ContainsKey(componentId))
+                    {
+                        componentWithNonKeyPathChanged.Add(componentId, fileId);
+                    }
+                }
+            }
+
+            foreach (var componentFile in componentWithNonKeyPathChanged)
+            {
+                // Make sure all changes to non keypath files also had a change in the keypath.
+                if (!componentWithChangedKeyPath.ContainsKey(componentFile.Key) && componentKeyPath.TryGetValue(componentFile.Key, out var keyPath))
+                {
+                    this.Messaging.Write(WarningMessages.UpdateOfNonKeyPathFile(componentFile.Value, componentFile.Key, keyPath));
+                }
+            }
+        }
+
+        private bool CompareFiles(string targetFile, string updatedFile)
+        {
+            bool? compared = null;
+            foreach (var extension in this.Extensions)
+            {
+                compared = extension.CompareFiles(targetFile, updatedFile);
+
+                if (compared.HasValue)
+                {
+                    break;
+                }
+            }
+
+            if (!compared.HasValue)
+            {
+                throw new InvalidOperationException(); // TODO: something needs to be said here that none of the binder file managers returned a result.
+            }
+
+            return compared.Value;
+        }
+    }
+}
diff --git a/src/WixToolset.Core.WindowsInstaller/Bind/LoadTableDefinitionsCommand.cs b/src/WixToolset.Core.WindowsInstaller/Bind/LoadTableDefinitionsCommand.cs
index 92ddad6f..1aa4065e 100644
--- a/src/WixToolset.Core.WindowsInstaller/Bind/LoadTableDefinitionsCommand.cs
+++ b/src/WixToolset.Core.WindowsInstaller/Bind/LoadTableDefinitionsCommand.cs
@@ -9,15 +9,22 @@ namespace WixToolset.Core.WindowsInstaller.Bind
     using WixToolset.Data;
     using WixToolset.Data.Tuples;
     using WixToolset.Data.WindowsInstaller;
+    using WixToolset.Extensibility;
 
     internal class LoadTableDefinitionsCommand
     {
-        public LoadTableDefinitionsCommand(IntermediateSection section) => this.Section = section;
-
-        public TableDefinitionCollection TableDefinitions { get; private set; }
+        public LoadTableDefinitionsCommand(IntermediateSection section, IEnumerable<IWindowsInstallerBackendBinderExtension> backendExtensions)
+        {
+            this.Section = section;
+            this.BackendExtensions = backendExtensions;
+        }
 
         private IntermediateSection Section { get; }
 
+        private IEnumerable<IWindowsInstallerBackendBinderExtension> BackendExtensions { get; }
+
+        public TableDefinitionCollection TableDefinitions { get; private set; }
+
         public TableDefinitionCollection Execute()
         {
             var tableDefinitions = new TableDefinitionCollection(WindowsInstallerStandardInternal.GetTableDefinitions());
@@ -28,6 +35,14 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                 tableDefinitions.Add(customTableDefinition);
             }
 
+            foreach (var backendExtension in this.BackendExtensions)
+            {
+                foreach (var tableDefinition in backendExtension.TableDefinitions)
+                {
+                    tableDefinitions.Add(tableDefinition);
+                }
+            }
+
             this.TableDefinitions = tableDefinitions;
             return this.TableDefinitions;
         }
diff --git a/src/WixToolset.Core.WindowsInstaller/Bind/MergeModulesCommand.cs b/src/WixToolset.Core.WindowsInstaller/Bind/MergeModulesCommand.cs
index 8c11555e..b90aecd1 100644
--- a/src/WixToolset.Core.WindowsInstaller/Bind/MergeModulesCommand.cs
+++ b/src/WixToolset.Core.WindowsInstaller/Bind/MergeModulesCommand.cs
@@ -277,7 +277,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
 
                         using (Record record = new Record(1))
                         {
-                            record.SetString(1, file.File.Id.Id);
+                            record.SetString(1, file.Id);
                             view.Execute(record);
                         }
 
@@ -288,7 +288,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                                 throw new InvalidOperationException("Failed to fetch a File row from the database that was merged in from a module.");
                             }
 
-                            recordUpdate.SetInteger(1, file.File.Sequence);
+                            recordUpdate.SetInteger(1, file.Sequence);
 
                             // Update the file attributes to match the compression specified
                             // on the Merge element or on the Package element.
@@ -300,12 +300,12 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                                 attributes = recordUpdate.GetInteger(2);
                             }
 
-                            if ((file.File.Attributes & FileTupleAttributes.Compressed) == FileTupleAttributes.Compressed)
+                            if (file.Compressed)
                             {
                                 attributes |= WindowsInstallerConstants.MsidbFileAttributesCompressed;
                                 attributes &= ~WindowsInstallerConstants.MsidbFileAttributesNoncompressed;
                             }
-                            else if ((file.File.Attributes & FileTupleAttributes.Uncompressed) == FileTupleAttributes.Uncompressed)
+                            else if (file.Uncompressed)
                             {
                                 attributes |= WindowsInstallerConstants.MsidbFileAttributesNoncompressed;
                                 attributes &= ~WindowsInstallerConstants.MsidbFileAttributesCompressed;
diff --git a/src/WixToolset.Core.WindowsInstaller/Bind/PatchTransform.cs b/src/WixToolset.Core.WindowsInstaller/Bind/PatchTransform.cs
new file mode 100644
index 00000000..5ada29de
--- /dev/null
+++ b/src/WixToolset.Core.WindowsInstaller/Bind/PatchTransform.cs
@@ -0,0 +1,246 @@
+// 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.Collections;
+    using System.Globalization;
+    using System.Text;
+    using System.Text.RegularExpressions;
+    using WixToolset.Data;
+    using WixToolset.Data.WindowsInstaller;
+    using WixToolset.Extensibility;
+
+    internal class PatchTransform
+    {
+        public PatchTransform(string baseline, WindowsInstallerData transform)
+        {
+            this.Baseline = baseline;
+            this.Transform = transform;
+        }
+
+        public string Baseline { get; }
+
+        public WindowsInstallerData Transform { get; }
+
+        /// <summary>
+        /// Validates that the differences in the transform are valid for patch transforms.
+        /// </summary>
+        public void Validate()
+        {
+#if TODO_PATCHING
+            // Changing the ProdocutCode in a patch transform is not recommended.
+            Table propertyTable = this.Transform.Tables["Property"];
+            if (null != propertyTable)
+            {
+                foreach (Row row in propertyTable.Rows)
+                {
+                    // Only interested in modified rows; fast check.
+                    if (RowOperation.Modify == row.Operation)
+                    {
+                        if (0 == String.CompareOrdinal("ProductCode", (string)row[0]))
+                        {
+                            this.OnMessage(WixWarnings.MajorUpgradePatchNotRecommended());
+                        }
+                    }
+                }
+            }
+
+            // If there is nothing in the component table we can return early because the remaining checks are component based.
+            Table componentTable = this.Transform.Tables["Component"];
+            if (null == componentTable)
+            {
+                return;
+            }
+
+            // Index Feature table row operations
+            Table featureTable = this.Transform.Tables["Feature"];
+            Table featureComponentsTable = this.Transform.Tables["FeatureComponents"];
+            Hashtable featureOps = null;
+            if (null != featureTable)
+            {
+                int capacity = featureTable.Rows.Count;
+                featureOps = new Hashtable(capacity);
+
+                foreach (Row row in featureTable.Rows)
+                {
+                    featureOps[(string)row[0]] = row.Operation;
+                }
+            }
+            else
+            {
+                featureOps = new Hashtable();
+            }
+
+            // Index Component table and check for keypath modifications
+            Hashtable deletedComponent = new Hashtable();
+            Hashtable componentKeyPath = new Hashtable();
+            foreach (Row row in componentTable.Rows)
+            {
+                string id = row.Fields[0].Data.ToString();
+                string keypath = (null == row.Fields[5].Data) ? String.Empty : row.Fields[5].Data.ToString();
+
+                componentKeyPath.Add(id, keypath);
+                if (RowOperation.Delete == row.Operation)
+                {
+                    deletedComponent.Add(id, row);
+                }
+                else if (RowOperation.Modify == row.Operation)
+                {
+                    if (row.Fields[1].Modified)
+                    {
+                        // Changing the guid of a component is equal to deleting the old one and adding a new one.
+                        deletedComponent.Add(id, row);
+                    }
+
+                    // If the keypath is modified its an error
+                    if (row.Fields[5].Modified)
+                    {
+                        this.OnMessage(WixErrors.InvalidKeypathChange(row.SourceLineNumbers, id, this.transformPath));
+                    }
+                }
+            }
+
+            // Verify changes in the file table
+            Table fileTable = this.Transform.Tables["File"];
+            if (null != fileTable)
+            {
+                Hashtable componentWithChangedKeyPath = new Hashtable();
+                foreach (Row row in fileTable.Rows)
+                {
+                    if (RowOperation.None != row.Operation)
+                    {
+                        string fileId = row.Fields[0].Data.ToString();
+                        string componentId = row.Fields[1].Data.ToString();
+
+                        // If this file is the keypath of a component
+                        if (String.Equals((string)componentKeyPath[componentId], fileId, StringComparison.Ordinal))
+                        {
+                            if (row.Fields[2].Modified)
+                            {
+                                // You cant change the filename of a file that is the keypath of a component.
+                                this.OnMessage(WixErrors.InvalidKeypathChange(row.SourceLineNumbers, componentId, this.transformPath));
+                            }
+
+                            if (!componentWithChangedKeyPath.ContainsKey(componentId))
+                            {
+                                componentWithChangedKeyPath.Add(componentId, fileId);
+                            }
+                        }
+
+                        if (RowOperation.Delete == row.Operation)
+                        {
+                            // If the file is removed from a component that is not deleted.
+                            if (!deletedComponent.ContainsKey(componentId))
+                            {
+                                bool foundRemoveFileEntry = false;
+                                string filename = Common.GetName((string)row[2], false, true);
+
+                                Table removeFileTable = this.Transform.Tables["RemoveFile"];
+                                if (null != removeFileTable)
+                                {
+                                    foreach (Row removeFileRow in removeFileTable.Rows)
+                                    {
+                                        if (RowOperation.Delete == removeFileRow.Operation)
+                                        {
+                                            continue;
+                                        }
+
+                                        if (componentId == (string)removeFileRow[1])
+                                        {
+                                            // Check if there is a RemoveFile entry for this file
+                                            if (null != removeFileRow[2])
+                                            {
+                                                string removeFileName = Common.GetName((string)removeFileRow[2], false, true);
+
+                                                // Convert the MSI format for a wildcard string to Regex format.
+                                                removeFileName = removeFileName.Replace('.', '|').Replace('?', '.').Replace("*", ".*").Replace("|", "\\.");
+
+                                                Regex regex = new Regex(removeFileName, RegexOptions.CultureInvariant | RegexOptions.IgnoreCase);
+                                                if (regex.IsMatch(filename))
+                                                {
+                                                    foundRemoveFileEntry = true;
+                                                    break;
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+
+                                if (!foundRemoveFileEntry)
+                                {
+                                    this.OnMessage(WixWarnings.InvalidRemoveFile(row.SourceLineNumbers, fileId, componentId));
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            if (0 < deletedComponent.Count)
+            {
+                // Index FeatureComponents table.
+                Hashtable featureComponents = new Hashtable();
+
+                if (null != featureComponentsTable)
+                {
+                    foreach (Row row in featureComponentsTable.Rows)
+                    {
+                        ArrayList features;
+                        string componentId = row.Fields[1].Data.ToString();
+
+                        if (featureComponents.Contains(componentId))
+                        {
+                            features = (ArrayList)featureComponents[componentId];
+                        }
+                        else
+                        {
+                            features = new ArrayList();
+                            featureComponents.Add(componentId, features);
+                        }
+                        features.Add(row.Fields[0].Data.ToString());
+                    }
+                }
+
+                // Check to make sure if a component was deleted, the feature was too.
+                foreach (DictionaryEntry entry in deletedComponent)
+                {
+                    if (featureComponents.Contains(entry.Key.ToString()))
+                    {
+                        ArrayList features = (ArrayList)featureComponents[entry.Key.ToString()];
+                        foreach (string featureId in features)
+                        {
+                            if (!featureOps.ContainsKey(featureId) || RowOperation.Delete != (RowOperation)featureOps[featureId])
+                            {
+                                // The feature was not deleted.
+                                this.OnMessage(WixErrors.InvalidRemoveComponent(((Row)entry.Value).SourceLineNumbers, entry.Key.ToString(), featureId, this.transformPath));
+                            }
+                        }
+                    }
+                }
+            }
+
+            // Warn if new components are added to existing features
+            if (null != featureComponentsTable)
+            {
+                foreach (Row row in featureComponentsTable.Rows)
+                {
+                    if (RowOperation.Add == row.Operation)
+                    {
+                        // Check if the feature is in the Feature table
+                        string feature_ = (string)row[0];
+                        string component_ = (string)row[1];
+
+                        // Features may not be present if not referenced
+                        if (!featureOps.ContainsKey(feature_) || RowOperation.Add != (RowOperation)featureOps[feature_])
+                        {
+                            this.OnMessage(WixWarnings.NewComponentAddedToExistingFeature(row.SourceLineNumbers, component_, feature_, this.transformPath));
+                        }
+                    }
+                }
+            }
+#endif
+            throw new NotImplementedException();
+        }
+    }
+}
diff --git a/src/WixToolset.Core.WindowsInstaller/Bind/ProcessUncompressedFilesCommand.cs b/src/WixToolset.Core.WindowsInstaller/Bind/ProcessUncompressedFilesCommand.cs
index 373ada38..13d47215 100644
--- a/src/WixToolset.Core.WindowsInstaller/Bind/ProcessUncompressedFilesCommand.cs
+++ b/src/WixToolset.Core.WindowsInstaller/Bind/ProcessUncompressedFilesCommand.cs
@@ -86,14 +86,14 @@ namespace WixToolset.Core.WindowsInstaller.Bind
 
                             // setup up the query record and find the appropriate file in the
                             // previously executed file view
-                            fileQueryRecord[1] = facade.File.Id.Id;
+                            fileQueryRecord[1] = facade.Id;
                             fileView.Execute(fileQueryRecord);
 
                             using (Record fileRecord = fileView.Fetch())
                             {
                                 if (null == fileRecord)
                                 {
-                                    throw new WixException(ErrorMessages.FileIdentifierNotFound(facade.File.SourceLineNumbers, facade.File.Id.Id));
+                                    throw new WixException(ErrorMessages.FileIdentifierNotFound(facade.SourceLineNumber, facade.Id));
                                 }
 
                                 relativeFileLayoutPath = this.PathResolver.GetFileSourcePath(directories, fileRecord[1], fileRecord[2], this.Compressed, this.LongNamesInImage);
@@ -102,7 +102,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                             // finally put together the base media layout path and the relative file layout path
                             var fileLayoutPath = Path.Combine(mediaLayoutDirectory, relativeFileLayoutPath);
 
-                            var transfer = this.BackendHelper.CreateFileTransfer(facade.File.Source.Path, fileLayoutPath, false, facade.File.SourceLineNumbers);
+                            var transfer = this.BackendHelper.CreateFileTransfer(facade.SourcePath, fileLayoutPath, false, facade.SourceLineNumber);
                             fileTransfers.Add(transfer);
 
                             // Track the location where the cabinet will be placed. If the transfer is
@@ -110,7 +110,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                             // because if the source and destination of the transfer is the same, we
                             // don't want to clean the file because we'd be deleting the original
                             // (and that would be bad).
-                            var tracked = this.BackendHelper.TrackFile(transfer.Destination, TrackedFileType.Final, facade.File.SourceLineNumbers);
+                            var tracked = this.BackendHelper.TrackFile(transfer.Destination, TrackedFileType.Final, facade.SourceLineNumber);
                             tracked.Clean = !transfer.Redundant;
 
                             trackedFiles.Add(tracked);
diff --git a/src/WixToolset.Core.WindowsInstaller/Bind/SequenceActionsCommand.cs b/src/WixToolset.Core.WindowsInstaller/Bind/SequenceActionsCommand.cs
index e9b0d612..749f9ac0 100644
--- a/src/WixToolset.Core.WindowsInstaller/Bind/SequenceActionsCommand.cs
+++ b/src/WixToolset.Core.WindowsInstaller/Bind/SequenceActionsCommand.cs
@@ -11,24 +11,25 @@ namespace WixToolset.Core.WindowsInstaller.Bind
     using WixToolset.Data.WindowsInstaller;
     using WixToolset.Extensibility.Services;
 
+    /// <summary>
+    /// Set sequence numbers for all the actions and create tuples in the output object.
+    /// </summary>
     internal class SequenceActionsCommand
     {
-        public SequenceActionsCommand(IntermediateSection section)
+        public SequenceActionsCommand(IMessaging messaging, IntermediateSection section)
         {
+            this.Messaging = messaging;
             this.Section = section;
 
             this.RelativeActionsForActions = new Dictionary<string, RelativeActions>();
         }
 
+        private IMessaging Messaging { get; }
+
         private IntermediateSection Section { get; }
 
         private Dictionary<string, RelativeActions> RelativeActionsForActions { get; }
 
-        public IMessaging Messaging { private get; set; }
-
-        /// <summary>
-        /// Set sequence numbers for all the actions and create tuples in the output object.
-        /// </summary>
         public void Execute()
         {
             var requiredActionTuples = new Dictionary<string, WixActionTuple>();
diff --git a/src/WixToolset.Core.WindowsInstaller/Bind/UpdateFileFacadesCommand.cs b/src/WixToolset.Core.WindowsInstaller/Bind/UpdateFileFacadesCommand.cs
index 1f2a22d9..81d46b41 100644
--- a/src/WixToolset.Core.WindowsInstaller/Bind/UpdateFileFacadesCommand.cs
+++ b/src/WixToolset.Core.WindowsInstaller/Bind/UpdateFileFacadesCommand.cs
@@ -59,27 +59,27 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             FileInfo fileInfo = null;
             try
             {
-                fileInfo = new FileInfo(facade.File.Source.Path);
+                fileInfo = new FileInfo(facade.SourcePath);
             }
             catch (ArgumentException)
             {
-                this.Messaging.Write(ErrorMessages.InvalidFileName(facade.File.SourceLineNumbers, facade.File.Source.Path));
+                this.Messaging.Write(ErrorMessages.InvalidFileName(facade.SourceLineNumber, facade.SourcePath));
                 return;
             }
             catch (PathTooLongException)
             {
-                this.Messaging.Write(ErrorMessages.InvalidFileName(facade.File.SourceLineNumbers, facade.File.Source.Path));
+                this.Messaging.Write(ErrorMessages.InvalidFileName(facade.SourceLineNumber, facade.SourcePath));
                 return;
             }
             catch (NotSupportedException)
             {
-                this.Messaging.Write(ErrorMessages.InvalidFileName(facade.File.SourceLineNumbers, facade.File.Source.Path));
+                this.Messaging.Write(ErrorMessages.InvalidFileName(facade.SourceLineNumber, facade.SourcePath));
                 return;
             }
 
             if (!fileInfo.Exists)
             {
-                this.Messaging.Write(ErrorMessages.CannotFindFile(facade.File.SourceLineNumbers, facade.File.Id.Id, facade.File.Name, facade.File.Source.Path));
+                this.Messaging.Write(ErrorMessages.CannotFindFile(facade.SourceLineNumber, facade.Id, facade.FileName, facade.SourcePath));
                 return;
             }
 
@@ -87,10 +87,10 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             {
                 if (Int32.MaxValue < fileStream.Length)
                 {
-                    throw new WixException(ErrorMessages.FileTooLarge(facade.File.SourceLineNumbers, facade.File.Source.Path));
+                    throw new WixException(ErrorMessages.FileTooLarge(facade.SourceLineNumber, facade.SourcePath));
                 }
 
-                facade.File.FileSize = Convert.ToInt32(fileStream.Length, CultureInfo.InvariantCulture);
+                facade.FileSize = Convert.ToInt32(fileStream.Length, CultureInfo.InvariantCulture);
             }
 
             string version = null;
@@ -103,7 +103,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             {
                 if (0x2 == e.NativeErrorCode) // ERROR_FILE_NOT_FOUND
                 {
-                    throw new WixException(ErrorMessages.FileNotFound(facade.File.SourceLineNumbers, fileInfo.FullName));
+                    throw new WixException(ErrorMessages.FileNotFound(facade.SourceLineNumber, fileInfo.FullName));
                 }
                 else
                 {
@@ -118,7 +118,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                 {
                     // not overwriting hash, so don't do the rest of these options.
                 }
-                else if (null != facade.File.Version)
+                else if (null != facade.Version)
                 {
                     // Search all of the file rows available to see if the specified version is actually a companion file. Yes, this looks
                     // very expensive and you're probably thinking it would be better to create an index of some sort to do an O(1) look up.
@@ -127,16 +127,16 @@ 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.File.Version.Equals(r.File.Id.Id, StringComparison.Ordinal)))
+                    if (!this.FileFacades.Any(r => facade.Version.Equals(r.Id, StringComparison.Ordinal)))
                     {
-                        this.Messaging.Write(WarningMessages.DefaultVersionUsedForUnversionedFile(facade.File.SourceLineNumbers, facade.File.Version, facade.File.Id.Id));
+                        this.Messaging.Write(WarningMessages.DefaultVersionUsedForUnversionedFile(facade.SourceLineNumber, facade.Version, facade.Id));
                     }
                 }
                 else
                 {
-                    if (null != facade.File.Language)
+                    if (null != facade.Language)
                     {
-                        this.Messaging.Write(WarningMessages.DefaultLanguageUsedForUnversionedFile(facade.File.SourceLineNumbers, facade.File.Language, facade.File.Id.Id));
+                        this.Messaging.Write(WarningMessages.DefaultLanguageUsedForUnversionedFile(facade.SourceLineNumber, facade.Language, facade.Id));
                     }
 
                     int[] hash;
@@ -148,7 +148,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                     {
                         if (0x2 == e.NativeErrorCode) // ERROR_FILE_NOT_FOUND
                         {
-                            throw new WixException(ErrorMessages.FileNotFound(facade.File.SourceLineNumbers, fileInfo.FullName));
+                            throw new WixException(ErrorMessages.FileNotFound(facade.SourceLineNumber, fileInfo.FullName));
                         }
                         else
                         {
@@ -158,7 +158,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
 
                     if (null == facade.Hash)
                     {
-                        facade.Hash = new MsiFileHashTuple(facade.File.SourceLineNumbers, facade.File.Id);
+                        facade.Hash = new MsiFileHashTuple(facade.SourceLineNumber, facade.Identifier);
                         this.Section.Tuples.Add(facade.Hash);
                     }
 
@@ -173,11 +173,11 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             {
                 // If no version was provided by the user, use the version from the file itself.
                 // This is the most common case.
-                if (String.IsNullOrEmpty(facade.File.Version))
+                if (String.IsNullOrEmpty(facade.Version))
                 {
-                    facade.File.Version = version;
+                    facade.Version = version;
                 }
-                else if (!this.FileFacades.Any(r => facade.File.Version.Equals(r.File.Id.Id, StringComparison.Ordinal))) // this looks expensive, but see explanation below.
+                else if (!this.FileFacades.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
@@ -188,41 +188,41 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                     //
                     // Also note this case can occur when the file is being updated using the WixBindUpdatedFiles extension mechanism.
                     // That's typically even more rare than companion files so again, no index, just search.
-                    facade.File.Version = version;
+                    facade.Version = version;
                 }
 
-                if (!String.IsNullOrEmpty(facade.File.Language) && String.IsNullOrEmpty(language))
+                if (!String.IsNullOrEmpty(facade.Language) && String.IsNullOrEmpty(language))
                 {
-                    this.Messaging.Write(WarningMessages.DefaultLanguageUsedForVersionedFile(facade.File.SourceLineNumbers, facade.File.Language, facade.File.Id.Id));
+                    this.Messaging.Write(WarningMessages.DefaultLanguageUsedForVersionedFile(facade.SourceLineNumber, facade.Language, facade.Id));
                 }
                 else // override the default provided by the user (usually nothing) with the actual language from the file itself.
                 {
-                    facade.File.Language = language;
+                    facade.Language = language;
                 }
 
                 // Populate the binder variables for this file information if requested.
                 if (null != this.VariableCache)
                 {
-                    if (!String.IsNullOrEmpty(facade.File.Version))
+                    if (!String.IsNullOrEmpty(facade.Version))
                     {
-                        var key = String.Format(CultureInfo.InvariantCulture, "fileversion.{0}", facade.File.Id.Id);
-                        this.VariableCache[key] = facade.File.Version;
+                        var key = String.Format(CultureInfo.InvariantCulture, "fileversion.{0}", facade.Id);
+                        this.VariableCache[key] = facade.Version;
                     }
 
-                    if (!String.IsNullOrEmpty(facade.File.Language))
+                    if (!String.IsNullOrEmpty(facade.Language))
                     {
-                        var key = String.Format(CultureInfo.InvariantCulture, "filelanguage.{0}", facade.File.Id.Id);
-                        this.VariableCache[key] = facade.File.Language;
+                        var key = String.Format(CultureInfo.InvariantCulture, "filelanguage.{0}", facade.Id);
+                        this.VariableCache[key] = facade.Language;
                     }
                 }
             }
 
             // If this is a CLR assembly, load the assembly and get the assembly name information
-            if (AssemblyType.DotNetAssembly == facade.Assembly?.Type)
+            if (AssemblyType.DotNetAssembly == facade.AssemblyType)
             {
                 try
                 {
-                    var assemblyName = AssemblyNameReader.ReadAssembly(facade.File.SourceLineNumbers, fileInfo.FullName, version);
+                    var assemblyName = AssemblyNameReader.ReadAssembly(facade.SourceLineNumber, fileInfo.FullName, version);
 
                     this.SetMsiAssemblyName(assemblyNameTuples, facade, "name", assemblyName.Name);
                     this.SetMsiAssemblyName(assemblyNameTuples, facade, "culture", assemblyName.Culture);
@@ -242,9 +242,9 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                     {
                         this.SetMsiAssemblyName(assemblyNameTuples, facade, "publicKeyToken", assemblyName.PublicKeyToken);
                     }
-                    else if (facade.Assembly.ApplicationFileRef == null)
+                    else if (facade.AssemblyApplicationFileRef == null)
                     {
-                        throw new WixException(ErrorMessages.GacAssemblyNoStrongName(facade.File.SourceLineNumbers, fileInfo.FullName, facade.File.ComponentRef));
+                        throw new WixException(ErrorMessages.GacAssemblyNoStrongName(facade.SourceLineNumber, fileInfo.FullName, facade.ComponentRef));
                     }
 
                     if (!String.IsNullOrEmpty(assemblyName.FileVersion))
@@ -255,7 +255,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                     // add the assembly name to the information cache
                     if (null != this.VariableCache)
                     {
-                        this.VariableCache[$"assemblyfullname.{facade.File.Id.Id}"] = assemblyName.GetFullName();
+                        this.VariableCache[$"assemblyfullname.{facade.Id}"] = assemblyName.GetFullName();
                     }
                 }
                 catch (WixException e)
@@ -263,20 +263,20 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                     this.Messaging.Write(e.Error);
                 }
             }
-            else if (AssemblyType.Win32Assembly == facade.Assembly?.Type)
+            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.File.Id.Id.Equals(facade.Assembly.ManifestFileRef, StringComparison.Ordinal));
+                var fileManifest = this.FileFacades.FirstOrDefault(r => r.Id.Equals(facade.AssemblyManifestFileRef, StringComparison.Ordinal));
                 if (null == fileManifest)
                 {
-                    this.Messaging.Write(ErrorMessages.MissingManifestForWin32Assembly(facade.File.SourceLineNumbers, facade.File.Id.Id, facade.Assembly.ManifestFileRef));
+                    this.Messaging.Write(ErrorMessages.MissingManifestForWin32Assembly(facade.SourceLineNumber, facade.Id, facade.AssemblyManifestFileRef));
                 }
 
                 try
                 {
-                    var assemblyName = AssemblyNameReader.ReadAssemblyManifest(facade.File.SourceLineNumbers, fileManifest.File.Source.Path);
+                    var assemblyName = AssemblyNameReader.ReadAssemblyManifest(facade.SourceLineNumber, fileManifest.SourcePath);
 
                     if (!String.IsNullOrEmpty(assemblyName.Name))
                     {
@@ -315,41 +315,41 @@ namespace WixToolset.Core.WindowsInstaller.Bind
         /// create a new row.
         /// </summary>
         /// <param name="assemblyNameTuples">MsiAssemblyName table.</param>
-        /// <param name="file">FileFacade containing the assembly read for the MsiAssemblyName row.</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, MsiAssemblyNameTuple> assemblyNameTuples, FileFacade file, string name, string value)
+        private void SetMsiAssemblyName(Dictionary<string, MsiAssemblyNameTuple> assemblyNameTuples, FileFacade facade, 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))
             {
-                this.Messaging.Write(WarningMessages.NullMsiAssemblyNameValue(file.File.SourceLineNumbers, file.File.ComponentRef, name));
+                this.Messaging.Write(WarningMessages.NullMsiAssemblyNameValue(facade.SourceLineNumber, facade.ComponentRef, name));
             }
             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 == file.Assembly.Type &&
-                    String.IsNullOrEmpty(file.Assembly.ApplicationFileRef) &&
-                    !String.Equals(Path.GetFileNameWithoutExtension(file.File.Name), value, StringComparison.OrdinalIgnoreCase))
+                if ("name" == name && AssemblyType.DotNetAssembly == facade.AssemblyType &&
+                    String.IsNullOrEmpty(facade.AssemblyApplicationFileRef) &&
+                    !String.Equals(Path.GetFileNameWithoutExtension(facade.FileName), value, StringComparison.OrdinalIgnoreCase))
                 {
-                    this.Messaging.Write(ErrorMessages.GACAssemblyIdentityWarning(file.File.SourceLineNumbers, Path.GetFileNameWithoutExtension(file.File.Name), value));
+                    this.Messaging.Write(ErrorMessages.GACAssemblyIdentityWarning(facade.SourceLineNumber, Path.GetFileNameWithoutExtension(facade.FileName), value));
                 }
 
                 // override directly authored value
-                var lookup = String.Concat(file.File.ComponentRef, "/", name);
+                var lookup = String.Concat(facade.ComponentRef, "/", name);
                 if (!assemblyNameTuples.TryGetValue(lookup, out var assemblyNameRow))
                 {
-                    assemblyNameRow = new MsiAssemblyNameTuple(file.File.SourceLineNumbers);
-                    assemblyNameRow.ComponentRef = file.File.ComponentRef;
+                    assemblyNameRow = new MsiAssemblyNameTuple(facade.SourceLineNumber);
+                    assemblyNameRow.ComponentRef = facade.ComponentRef;
                     assemblyNameRow.Name = name;
                     assemblyNameRow.Value = value;
 
-                    if (null == file.AssemblyNames)
+                    if (null == facade.AssemblyNames)
                     {
-                        file.AssemblyNames = new List<MsiAssemblyNameTuple>();
+                        facade.AssemblyNames = new List<MsiAssemblyNameTuple>();
                     }
 
-                    file.AssemblyNames.Add(assemblyNameRow);
+                    facade.AssemblyNames.Add(assemblyNameRow);
                     this.Section.Tuples.Add(assemblyNameRow);
                 }
 
@@ -357,7 +357,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
 
                 if (this.VariableCache != null)
                 {
-                    var key = String.Format(CultureInfo.InvariantCulture, "assembly{0}.{1}", name, file.File.Id.Id).ToLowerInvariant();
+                    var key = String.Format(CultureInfo.InvariantCulture, "assembly{0}.{1}", name, facade.Id).ToLowerInvariant();
                     this.VariableCache[key] = value;
                 }
             }
diff --git a/src/WixToolset.Core.WindowsInstaller/Bind/UpdateMediaSequencesCommand.cs b/src/WixToolset.Core.WindowsInstaller/Bind/UpdateMediaSequencesCommand.cs
index f9e3bd5a..ae872f45 100644
--- a/src/WixToolset.Core.WindowsInstaller/Bind/UpdateMediaSequencesCommand.cs
+++ b/src/WixToolset.Core.WindowsInstaller/Bind/UpdateMediaSequencesCommand.cs
@@ -33,7 +33,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
 
                 // Order by Component to group the files by directory.
                 var optimized = this.OptimizedFileFacades();
-                foreach (var fileId in optimized.Select(f => f.File.Id.Id))
+                foreach (var fileId in optimized.Select(f => f.Id))
                 {
                     var fileRow = fileRows.Get(fileId);
                     fileRow.Sequence = ++lastSequence;
@@ -41,13 +41,13 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             }
             else
             {
-                int lastSequence = 0;
+                var lastSequence = 0;
                 MediaRow mediaRow = null;
-                Dictionary<int, List<FileFacade>> patchGroups = new Dictionary<int, List<FileFacade>>();
+                var patchGroups = new Dictionary<int, List<FileFacade>>();
 
                 // sequence the non-patch-added files
                 var optimized = this.OptimizedFileFacades();
-                foreach (FileFacade facade in optimized)
+                foreach (var facade in optimized)
                 {
                     if (null == mediaRow)
                     {
@@ -64,19 +64,19 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                         mediaRow = mediaRows.Get(facade.DiskId);
                     }
 
-                    if (facade.File.PatchGroup.HasValue)
+                    if (facade.PatchGroup.HasValue)
                     {
-                        if (patchGroups.TryGetValue(facade.File.PatchGroup.Value, out var patchGroup))
+                        if (patchGroups.TryGetValue(facade.PatchGroup.Value, out var patchGroup))
                         {
                             patchGroup = new List<FileFacade>();
-                            patchGroups.Add(facade.File.PatchGroup.Value, patchGroup);
+                            patchGroups.Add(facade.PatchGroup.Value, patchGroup);
                         }
 
                         patchGroup.Add(facade);
                     }
                     else
                     {
-                        var fileRow = fileRows.Get(facade.File.Id.Id);
+                        var fileRow = fileRows.Get(facade.Id);
                         fileRow.Sequence = ++lastSequence;
                     }
                 }
@@ -102,7 +102,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                             mediaRow = mediaRows.Get(facade.DiskId);
                         }
 
-                        var fileRow = fileRows.Get(facade.File.Id.Id);
+                        var fileRow = fileRows.Get(facade.Id);
                         fileRow.Sequence = ++lastSequence;
                     }
                 }
@@ -119,7 +119,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             // TODO: Sort these facades even smarter by directory path and component id 
             //       and maybe file size or file extension and other creative ideas to
             //       get optimal install speed out of MSI.
-            return this.FileFacades.OrderBy(f => f.File.ComponentRef);
+            return this.FileFacades.OrderBy(f => f.ComponentRef);
         }
     }
 }
diff --git a/src/WixToolset.Core.WindowsInstaller/Data/tables.xml b/src/WixToolset.Core.WindowsInstaller/Data/tables.xml
index e4b5e954..7cd1767b 100644
--- a/src/WixToolset.Core.WindowsInstaller/Data/tables.xml
+++ b/src/WixToolset.Core.WindowsInstaller/Data/tables.xml
@@ -156,6 +156,10 @@
                 minValue="0" maxValue="32767" description="Integer containing bit flags representing file attributes (with the decimal value of each bit position in parentheses)"/>
         <columnDefinition name="Sequence" type="number" length="4"
                 minValue="1" maxValue="2147483647" description="Sequence with respect to the media images; order must track cabinet order."/>
+        <columnDefinition name="DiskId" type="number" length="4" unreal="yes"
+                minValue="1" maxValue="32767" description="Disk identifier for the file."/>
+        <columnDefinition name="Source" type="object" length="0" unreal="yes"
+                category="binary" description="Path to source of file."/>
     </tableDefinition>
     <tableDefinition name="CCPSearch">
         <columnDefinition name="Signature_" type="string" length="72" primaryKey="yes"
diff --git a/src/WixToolset.Core.WindowsInstaller/Differ.cs b/src/WixToolset.Core.WindowsInstaller/Differ.cs
index 32172ffd..0e1a7315 100644
--- a/src/WixToolset.Core.WindowsInstaller/Differ.cs
+++ b/src/WixToolset.Core.WindowsInstaller/Differ.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 DELETE
+
 namespace WixToolset.Core.WindowsInstaller
 {
     using System;
@@ -604,3 +606,5 @@ namespace WixToolset.Core.WindowsInstaller
         }
     }
 }
+
+#endif
diff --git a/src/WixToolset.Core.WindowsInstaller/Inscribe/InscribeMsiPackageCommand.cs b/src/WixToolset.Core.WindowsInstaller/Inscribe/InscribeMsiPackageCommand.cs
index ff7472ff..582e179e 100644
--- a/src/WixToolset.Core.WindowsInstaller/Inscribe/InscribeMsiPackageCommand.cs
+++ b/src/WixToolset.Core.WindowsInstaller/Inscribe/InscribeMsiPackageCommand.cs
@@ -33,40 +33,40 @@ namespace WixToolset.Core.WindowsInstaller.Inscribe
         public bool Execute()
         {
             // Keeps track of whether we've encountered at least one signed cab or not - we'll throw a warning if no signed cabs were encountered
-            bool foundUnsignedExternals = false;
-            bool shouldCommit = false;
+            var foundUnsignedExternals = false;
+            var shouldCommit = false;
 
-            FileAttributes attributes = File.GetAttributes(this.Context.InputFilePath);
+            var attributes = File.GetAttributes(this.Context.InputFilePath);
             if (FileAttributes.ReadOnly == (attributes & FileAttributes.ReadOnly))
             {
                 this.Messaging.Write(ErrorMessages.ReadOnlyOutputFile(this.Context.InputFilePath));
                 return shouldCommit;
             }
 
-            using (Database database = new Database(this.Context.InputFilePath, OpenDatabase.Transact))
+            using (var database = new Database(this.Context.InputFilePath, OpenDatabase.Transact))
             {
                 // Just use the English codepage, because the tables we're importing only have binary streams / MSI identifiers / other non-localizable content
-                int codepage = 1252;
+                var codepage = 1252;
 
                 // list of certificates for this database (hash/identifier)
-                Dictionary<string, string> certificates = new Dictionary<string, string>();
+                var certificates = new Dictionary<string, string>();
 
                 // Reset the in-memory tables for this new database
-                Table digitalSignatureTable = new Table(this.TableDefinitions["MsiDigitalSignature"]);
-                Table digitalCertificateTable = new Table(this.TableDefinitions["MsiDigitalCertificate"]);
+                var digitalSignatureTable = new Table(this.TableDefinitions["MsiDigitalSignature"]);
+                var digitalCertificateTable = new Table(this.TableDefinitions["MsiDigitalCertificate"]);
 
                 // If any digital signature records exist that are not of the media type, preserve them
                 if (database.TableExists("MsiDigitalSignature"))
                 {
-                    using (View digitalSignatureView = database.OpenExecuteView("SELECT `Table`, `SignObject`, `DigitalCertificate_`, `Hash` FROM `MsiDigitalSignature` WHERE `Table` <> 'Media'"))
+                    using (var digitalSignatureView = database.OpenExecuteView("SELECT `Table`, `SignObject`, `DigitalCertificate_`, `Hash` FROM `MsiDigitalSignature` WHERE `Table` <> 'Media'"))
                     {
-                        foreach (Record digitalSignatureRecord in digitalSignatureView.Records)
+                        foreach (var digitalSignatureRecord in digitalSignatureView.Records)
                         {
                             Row digitalSignatureRow = null;
                             digitalSignatureRow = digitalSignatureTable.CreateRow(null);
 
-                            string table = digitalSignatureRecord.GetString(0);
-                            string signObject = digitalSignatureRecord.GetString(1);
+                            var table = digitalSignatureRecord.GetString(0);
+                            var signObject = digitalSignatureRecord.GetString(1);
 
                             digitalSignatureRow[0] = table;
                             digitalSignatureRow[1] = signObject;
@@ -75,16 +75,16 @@ namespace WixToolset.Core.WindowsInstaller.Inscribe
                             if (false == digitalSignatureRecord.IsNull(3))
                             {
                                 // Export to a file, because the MSI API's require us to provide a file path on disk
-                                string hashPath = Path.Combine(this.Context.IntermediateFolder, "MsiDigitalSignature");
-                                string hashFileName = string.Concat(table, ".", signObject, ".bin");
+                                var hashPath = Path.Combine(this.Context.IntermediateFolder, "MsiDigitalSignature");
+                                var hashFileName = String.Concat(table, ".", signObject, ".bin");
 
                                 Directory.CreateDirectory(hashPath);
                                 hashPath = Path.Combine(hashPath, hashFileName);
 
-                                using (FileStream fs = File.Create(hashPath))
+                                using (var fs = File.Create(hashPath))
                                 {
                                     int bytesRead;
-                                    byte[] buffer = new byte[1024 * 4];
+                                    var buffer = new byte[1024 * 4];
 
                                     while (0 != (bytesRead = digitalSignatureRecord.GetStream(3, buffer, buffer.Length)))
                                     {
@@ -101,21 +101,21 @@ namespace WixToolset.Core.WindowsInstaller.Inscribe
                 // If any digital certificates exist, extract and preserve them
                 if (database.TableExists("MsiDigitalCertificate"))
                 {
-                    using (View digitalCertificateView = database.OpenExecuteView("SELECT * FROM `MsiDigitalCertificate`"))
+                    using (var digitalCertificateView = database.OpenExecuteView("SELECT * FROM `MsiDigitalCertificate`"))
                     {
-                        foreach (Record digitalCertificateRecord in digitalCertificateView.Records)
+                        foreach (var digitalCertificateRecord in digitalCertificateView.Records)
                         {
-                            string certificateId = digitalCertificateRecord.GetString(1); // get the identifier of the certificate
+                            var certificateId = digitalCertificateRecord.GetString(1); // get the identifier of the certificate
 
                             // Export to a file, because the MSI API's require us to provide a file path on disk
-                            string certPath = Path.Combine(this.Context.IntermediateFolder, "MsiDigitalCertificate");
+                            var certPath = Path.Combine(this.Context.IntermediateFolder, "MsiDigitalCertificate");
                             Directory.CreateDirectory(certPath);
-                            certPath = Path.Combine(certPath, string.Concat(certificateId, ".cer"));
+                            certPath = Path.Combine(certPath, String.Concat(certificateId, ".cer"));
 
-                            using (FileStream fs = File.Create(certPath))
+                            using (var fs = File.Create(certPath))
                             {
                                 int bytesRead;
-                                byte[] buffer = new byte[1024 * 4];
+                                var buffer = new byte[1024 * 4];
 
                                 while (0 != (bytesRead = digitalCertificateRecord.GetStream(2, buffer, buffer.Length)))
                                 {
@@ -124,37 +124,37 @@ namespace WixToolset.Core.WindowsInstaller.Inscribe
                             }
 
                             // Add it to our "add to MsiDigitalCertificate" table dictionary
-                            Row digitalCertificateRow = digitalCertificateTable.CreateRow(null);
+                            var digitalCertificateRow = digitalCertificateTable.CreateRow(null);
                             digitalCertificateRow[0] = certificateId;
 
                             // Now set the file path on disk where this binary stream will be picked up at import time
-                            digitalCertificateRow[1] = string.Concat(certificateId, ".cer");
+                            digitalCertificateRow[1] = String.Concat(certificateId, ".cer");
 
                             // Load the cert to get it's thumbprint
-                            X509Certificate cert = X509Certificate.CreateFromCertFile(certPath);
-                            X509Certificate2 cert2 = new X509Certificate2(cert);
+                            var cert = X509Certificate.CreateFromCertFile(certPath);
+                            var cert2 = new X509Certificate2(cert);
 
                             certificates.Add(cert2.Thumbprint, certificateId);
                         }
                     }
                 }
 
-                using (View mediaView = database.OpenExecuteView("SELECT * FROM `Media`"))
+                using (var mediaView = database.OpenExecuteView("SELECT * FROM `Media`"))
                 {
-                    foreach (Record mediaRecord in mediaView.Records)
+                    foreach (var mediaRecord in mediaView.Records)
                     {
                         X509Certificate2 cert2 = null;
                         Row digitalSignatureRow = null;
 
-                        string cabName = mediaRecord.GetString(4); // get the name of the cab
+                        var cabName = mediaRecord.GetString(4); // get the name of the cab
                                                                    // If there is no cabinet or it's an internal cab, skip it.
                         if (String.IsNullOrEmpty(cabName) || cabName.StartsWith("#", StringComparison.Ordinal))
                         {
                             continue;
                         }
 
-                        string cabId = mediaRecord.GetString(1); // get the ID of the cab
-                        string cabPath = Path.Combine(Path.GetDirectoryName(this.Context.InputFilePath), cabName);
+                        var cabId = mediaRecord.GetString(1); // get the ID of the cab
+                        var cabPath = Path.Combine(Path.GetDirectoryName(this.Context.InputFilePath), cabName);
 
                         // If the cabs aren't there, throw an error but continue to catch the other errors
                         if (!File.Exists(cabPath))
@@ -166,12 +166,12 @@ namespace WixToolset.Core.WindowsInstaller.Inscribe
                         try
                         {
                             // Get the certificate from the cab
-                            X509Certificate signedFileCert = X509Certificate.CreateFromSignedFile(cabPath);
+                            var signedFileCert = X509Certificate.CreateFromSignedFile(cabPath);
                             cert2 = new X509Certificate2(signedFileCert);
                         }
                         catch (System.Security.Cryptography.CryptographicException e)
                         {
-                            uint HResult = unchecked((uint)Marshal.GetHRForException(e));
+                            var HResult = unchecked((uint)Marshal.GetHRForException(e));
 
                             // If the file has no cert, continue, but flag that we found at least one so we can later give a warning
                             if (0x80092009 == HResult) // CRYPT_E_NO_MATCH
@@ -197,26 +197,26 @@ namespace WixToolset.Core.WindowsInstaller.Inscribe
                         if (!certificates.ContainsKey(cert2.Thumbprint))
                         {
                             // generate a stable identifier
-                            string certificateGeneratedId = Common.GenerateIdentifier("cer", cert2.Thumbprint);
+                            var certificateGeneratedId = Common.GenerateIdentifier("cer", cert2.Thumbprint);
 
                             // Add it to our "add to MsiDigitalCertificate" table dictionary
-                            Row digitalCertificateRow = digitalCertificateTable.CreateRow(null);
+                            var digitalCertificateRow = digitalCertificateTable.CreateRow(null);
                             digitalCertificateRow[0] = certificateGeneratedId;
 
                             // Export to a file, because the MSI API's require us to provide a file path on disk
-                            string certPath = Path.Combine(this.Context.IntermediateFolder, "MsiDigitalCertificate");
+                            var certPath = Path.Combine(this.Context.IntermediateFolder, "MsiDigitalCertificate");
                             Directory.CreateDirectory(certPath);
-                            certPath = Path.Combine(certPath, string.Concat(cert2.Thumbprint, ".cer"));
+                            certPath = Path.Combine(certPath, String.Concat(cert2.Thumbprint, ".cer"));
                             File.Delete(certPath);
 
-                            using (BinaryWriter writer = new BinaryWriter(File.Open(certPath, FileMode.Create)))
+                            using (var writer = new BinaryWriter(File.Open(certPath, FileMode.Create)))
                             {
                                 writer.Write(cert2.RawData);
                                 writer.Close();
                             }
 
                             // Now set the file path on disk where this binary stream will be picked up at import time
-                            digitalCertificateRow[1] = string.Concat(cert2.Thumbprint, ".cer");
+                            digitalCertificateRow[1] = String.Concat(cert2.Thumbprint, ".cer");
 
                             certificates.Add(cert2.Thumbprint, certificateGeneratedId);
                         }
diff --git a/src/WixToolset.Core.WindowsInstaller/MspBackend.cs b/src/WixToolset.Core.WindowsInstaller/MspBackend.cs
index b6e72e11..8aa450bf 100644
--- a/src/WixToolset.Core.WindowsInstaller/MspBackend.cs
+++ b/src/WixToolset.Core.WindowsInstaller/MspBackend.cs
@@ -3,36 +3,74 @@
 namespace WixToolset.Core.WindowsInstaller
 {
     using System;
-    using System.ComponentModel;
+    using System.Collections.Generic;
     using System.IO;
-    using WixToolset.Core.Native;
+    using System.Linq;
+    using WixToolset.Core.WindowsInstaller.Bind;
+    using WixToolset.Core.WindowsInstaller.Msi;
     using WixToolset.Core.WindowsInstaller.Unbind;
     using WixToolset.Data;
-    using WixToolset.Data.Bind;
+    using WixToolset.Data.Tuples;
+    using WixToolset.Data.WindowsInstaller;
     using WixToolset.Extensibility;
     using WixToolset.Extensibility.Data;
-    using WixToolset.Ole32;
+    using WixToolset.Extensibility.Services;
 
     internal class MspBackend : IBackend
     {
         public IBindResult Bind(IBindContext context)
         {
-            throw new NotImplementedException();
-        }
+            var messaging = context.ServiceProvider.GetService<IMessaging>();
 
-        public IDecompileResult Decompile(IDecompileContext context)
-        {
-            throw new NotImplementedException();
-        }
+            var extensionManager = context.ServiceProvider.GetService<IExtensionManager>();
 
-        public bool Inscribe(IInscribeContext context)
-        {
-            throw new NotImplementedException();
+            var backendExtensions = extensionManager.GetServices<IWindowsInstallerBackendBinderExtension>();
+
+            foreach (var extension in backendExtensions)
+            {
+                extension.PreBackendBind(context);
+            }
+
+            // Create transforms named in patch transforms.
+            IEnumerable<PatchTransform> patchTransforms;
+            {
+                var command = new CreatePatchTransformsCommand(messaging, context.IntermediateRepresentation, context.IntermediateFolder);
+                patchTransforms = command.Execute();
+            }
+
+            // Enhance the intermediate by attaching the created patch transforms.
+            IEnumerable<SubStorage> subStorages;
+            {
+                var command = new AttachPatchTransformsCommand(messaging, context.IntermediateRepresentation, patchTransforms);
+                subStorages = command.Execute();
+            }
+
+            // Create WindowsInstallerData with patch metdata and transforms as sub-storages
+            // Create MSP from WindowsInstallerData
+            using (var command = new BindDatabaseCommand(context, backendExtensions, subStorages, null))
+            {
+                command.Execute();
+
+                var result = context.ServiceProvider.GetService<IBindResult>();
+                result.FileTransfers = command.FileTransfers;
+                result.TrackedFiles = command.TrackedFiles;
+
+                foreach (var extension in backendExtensions)
+                {
+                    extension.PostBackendBind(result, command.Wixout);
+                }
+
+                return result;
+            }
         }
 
+        public IDecompileResult Decompile(IDecompileContext context) => throw new NotImplementedException();
+
+        public bool Inscribe(IInscribeContext context) => throw new NotImplementedException();
+
         public Intermediate Unbind(IUnbindContext context)
         {
-#if REVISIT_FOR_PATCHING
+#if TODO_PATCHING
             Output patch;
 
             // patch files are essentially database files (use a special flag to let the API know its a patch file)
@@ -116,4 +154,4 @@ namespace WixToolset.Core.WindowsInstaller
             throw new NotImplementedException();
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/WixToolset.Core.WindowsInstaller/MstBackend.cs b/src/WixToolset.Core.WindowsInstaller/MstBackend.cs
index b64f417a..a6d86c10 100644
--- a/src/WixToolset.Core.WindowsInstaller/MstBackend.cs
+++ b/src/WixToolset.Core.WindowsInstaller/MstBackend.cs
@@ -12,7 +12,7 @@ namespace WixToolset.Core.WindowsInstaller
     {
         public IBindResult Bind(IBindContext context)
         {
-#if REVISIT_FOR_PATCHING
+#if TODO_PATCHING
             var command = new BindTransformCommand();
             command.Extensions = context.Extensions;
             command.TempFilesLocation = context.IntermediateFolder;
diff --git a/src/WixToolset.Core.WindowsInstaller/Ole32/Storage.cs b/src/WixToolset.Core.WindowsInstaller/Ole32/Storage.cs
index c6a43bc4..541d899a 100644
--- a/src/WixToolset.Core.WindowsInstaller/Ole32/Storage.cs
+++ b/src/WixToolset.Core.WindowsInstaller/Ole32/Storage.cs
@@ -63,8 +63,8 @@ namespace WixToolset.Ole32
     /// </summary>
     internal sealed class Storage : IDisposable
     {
+        private readonly IStorage storage;
         private bool disposed;
-        private IStorage storage;
 
         /// <summary>
         /// Instantiate a new Storage.
diff --git a/src/WixToolset.Core.WindowsInstaller/Patch.cs b/src/WixToolset.Core.WindowsInstaller/Patch.cs
index 6549e830..42cd7152 100644
--- a/src/WixToolset.Core.WindowsInstaller/Patch.cs
+++ b/src/WixToolset.Core.WindowsInstaller/Patch.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 DELETE
+
 namespace WixToolset.Data
 {
     using System;
@@ -50,7 +52,6 @@ namespace WixToolset.Data
         [SuppressMessage("Microsoft.Globalization", "CA1303:DoNotPassLiteralsAsLocalizedParameters", MessageId = "System.InvalidOperationException.#ctor(System.String)")]
         public void AttachTransforms(List<PatchTransform> transforms)
         {
-#if REVISIT_FOR_PATCHING
             // Track if at least one transform gets attached.
             bool attachedTransform = false;
 
@@ -1229,8 +1230,10 @@ namespace WixToolset.Data
             }
 
             return pairedTransform;
-#endif
+
             throw new NotImplementedException();
         }
     }
 }
+
+#endif
diff --git a/src/WixToolset.Core.WindowsInstaller/PatchTransform.cs b/src/WixToolset.Core.WindowsInstaller/PatchTransform.cs
index 0dc1e874..f58ca53f 100644
--- a/src/WixToolset.Core.WindowsInstaller/PatchTransform.cs
+++ b/src/WixToolset.Core.WindowsInstaller/PatchTransform.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 DELETE
+
 namespace WixToolset
 {
     using System;
@@ -50,7 +52,6 @@ namespace WixToolset
         /// </summary>
         public void Validate()
         {
-#if REVISIT_FOR_PATCHING
             // Changing the ProdocutCode in a patch transform is not recommended.
             Table propertyTable = this.Transform.Tables["Property"];
             if (null != propertyTable)
@@ -261,8 +262,10 @@ namespace WixToolset
                     }
                 }
             }
-#endif
+
             throw new NotImplementedException();
         }
     }
 }
+
+#endif
\ No newline at end of file
diff --git a/src/WixToolset.Core.WindowsInstaller/Unbind/UnbindMsiOrMsmCommand.cs b/src/WixToolset.Core.WindowsInstaller/Unbind/UnbindMsiOrMsmCommand.cs
index eca51caf..eea0fe23 100644
--- a/src/WixToolset.Core.WindowsInstaller/Unbind/UnbindMsiOrMsmCommand.cs
+++ b/src/WixToolset.Core.WindowsInstaller/Unbind/UnbindMsiOrMsmCommand.cs
@@ -19,7 +19,7 @@ namespace WixToolset.Core.WindowsInstaller.Unbind
 
         public Intermediate Execute()
         {
-#if REVISIT_FOR_PATCHING
+#if TODO_PATCHING
             Output output;
 
             try
diff --git a/src/WixToolset.Core.WindowsInstaller/Unbind/UnbindTranformCommand.cs b/src/WixToolset.Core.WindowsInstaller/Unbind/UnbindTranformCommand.cs
index bdf8d542..9261fda0 100644
--- a/src/WixToolset.Core.WindowsInstaller/Unbind/UnbindTranformCommand.cs
+++ b/src/WixToolset.Core.WindowsInstaller/Unbind/UnbindTranformCommand.cs
@@ -4,6 +4,7 @@ namespace WixToolset.Core.WindowsInstaller.Unbind
 {
     using System;
     using System.Collections;
+    using System.Collections.Generic;
     using System.ComponentModel;
     using System.Globalization;
     using System.IO;
@@ -12,7 +13,6 @@ namespace WixToolset.Core.WindowsInstaller.Unbind
     using WixToolset.Core.WindowsInstaller.Msi;
     using WixToolset.Data;
     using WixToolset.Data.WindowsInstaller;
-    using WixToolset.Extensibility;
     using WixToolset.Extensibility.Services;
 
     internal class UnbindTransformCommand
@@ -41,21 +41,21 @@ namespace WixToolset.Core.WindowsInstaller.Unbind
         
         public WindowsInstallerData Execute()
         {
-            WindowsInstallerData transform = new WindowsInstallerData(new SourceLineNumber(this.TransformFile));
+            var transform = new WindowsInstallerData(new SourceLineNumber(this.TransformFile));
             transform.Type = OutputType.Transform;
 
             // get the summary information table
-            using (SummaryInformation summaryInformation = new SummaryInformation(this.TransformFile))
+            using (var summaryInformation = new SummaryInformation(this.TransformFile))
             {
-                Table table = transform.EnsureTable(this.TableDefinitions["_SummaryInformation"]);
+                var table = transform.EnsureTable(this.TableDefinitions["_SummaryInformation"]);
 
-                for (int i = 1; 19 >= i; i++)
+                for (var i = 1; 19 >= i; i++)
                 {
-                    string value = summaryInformation.GetProperty(i);
+                    var value = summaryInformation.GetProperty(i);
 
                     if (0 < value.Length)
                     {
-                        Row row = table.CreateRow(transform.SourceLineNumbers);
+                        var row = table.CreateRow(transform.SourceLineNumbers);
                         row[0] = i;
                         row[1] = value;
                     }
@@ -63,9 +63,9 @@ namespace WixToolset.Core.WindowsInstaller.Unbind
             }
 
             // create a schema msi which hopefully matches the table schemas in the transform
-            WindowsInstallerData schemaOutput = new WindowsInstallerData(null);
-            string msiDatabaseFile = Path.Combine(this.IntermediateFolder, "schema.msi");
-            foreach (TableDefinition tableDefinition in this.TableDefinitions)
+            var schemaOutput = new WindowsInstallerData(null);
+            var msiDatabaseFile = Path.Combine(this.IntermediateFolder, "schema.msi");
+            foreach (var tableDefinition in this.TableDefinitions)
             {
                 // skip unreal tables and the Patch table
                 if (!tableDefinition.Unreal && "Patch" != tableDefinition.Name)
@@ -74,40 +74,40 @@ namespace WixToolset.Core.WindowsInstaller.Unbind
                 }
             }
 
-            Hashtable addedRows = new Hashtable();
+            var addedRows = new Dictionary<string, Row>();
             Table transformViewTable;
 
             // Bind the schema msi.
             this.GenerateDatabase(schemaOutput, msiDatabaseFile);
 
             // apply the transform to the database and retrieve the modifications
-            using (Database msiDatabase = new Database(msiDatabaseFile, OpenDatabase.Transact))
+            using (var msiDatabase = new Database(msiDatabaseFile, OpenDatabase.Transact))
             {
                 // apply the transform with the ViewTransform option to collect all the modifications
                 msiDatabase.ApplyTransform(this.TransformFile, TransformErrorConditions.All | TransformErrorConditions.ViewTransform);
 
                 // unbind the database
                 var unbindCommand = new UnbindDatabaseCommand(this.Messaging, msiDatabase, msiDatabaseFile, OutputType.Product, this.ExportBasePath, this.IntermediateFolder, false, false, skipSummaryInfo: true);
-                WindowsInstallerData transformViewOutput = unbindCommand.Execute();
+                var transformViewOutput = unbindCommand.Execute();
 
                 // index the added and possibly modified rows (added rows may also appears as modified rows)
                 transformViewTable = transformViewOutput.Tables["_TransformView"];
-                Hashtable modifiedRows = new Hashtable();
-                foreach (Row row in transformViewTable.Rows)
+                var modifiedRows = new Hashtable();
+                foreach (var row in transformViewTable.Rows)
                 {
-                    string tableName = (string)row[0];
-                    string columnName = (string)row[1];
-                    string primaryKeys = (string)row[2];
+                    var tableName = (string)row[0];
+                    var columnName = (string)row[1];
+                    var primaryKeys = (string)row[2];
 
                     if ("INSERT" == columnName)
                     {
-                        string index = String.Concat(tableName, ':', primaryKeys);
+                        var index = String.Concat(tableName, ':', primaryKeys);
 
                         addedRows.Add(index, null);
                     }
                     else if ("CREATE" != columnName && "DELETE" != columnName && "DROP" != columnName && null != primaryKeys) // modified row
                     {
-                        string index = String.Concat(tableName, ':', primaryKeys);
+                        var index = String.Concat(tableName, ':', primaryKeys);
 
                         modifiedRows[index] = row;
                     }
@@ -116,16 +116,16 @@ namespace WixToolset.Core.WindowsInstaller.Unbind
                 // create placeholder rows for modified rows to make the transform insert the updated values when its applied
                 foreach (Row row in modifiedRows.Values)
                 {
-                    string tableName = (string)row[0];
-                    string columnName = (string)row[1];
-                    string primaryKeys = (string)row[2];
+                    var tableName = (string)row[0];
+                    var columnName = (string)row[1];
+                    var primaryKeys = (string)row[2];
 
-                    string index = String.Concat(tableName, ':', primaryKeys);
+                    var index = String.Concat(tableName, ':', primaryKeys);
 
                     // ignore information for added rows
-                    if (!addedRows.Contains(index))
+                    if (!addedRows.ContainsKey(index))
                     {
-                        Table table = schemaOutput.Tables[tableName];
+                        var table = schemaOutput.Tables[tableName];
                         this.CreateRow(table, primaryKeys, true);
                     }
                 }
@@ -135,7 +135,7 @@ namespace WixToolset.Core.WindowsInstaller.Unbind
             this.GenerateDatabase(schemaOutput, msiDatabaseFile);
 
             // apply the transform to the database and retrieve the modifications
-            using (Database msiDatabase = new Database(msiDatabaseFile, OpenDatabase.Transact))
+            using (var msiDatabase = new Database(msiDatabaseFile, OpenDatabase.Transact))
             {
                 try
                 {
@@ -158,26 +158,26 @@ namespace WixToolset.Core.WindowsInstaller.Unbind
 
                 // unbind the database
                 var unbindCommand = new UnbindDatabaseCommand(this.Messaging, msiDatabase, msiDatabaseFile, OutputType.Product, this.ExportBasePath, this.IntermediateFolder, false, false, skipSummaryInfo: true);
-                WindowsInstallerData output = unbindCommand.Execute();
+                var output = unbindCommand.Execute();
 
                 // index all the rows to easily find modified rows
-                Hashtable rows = new Hashtable();
-                foreach (Table table in output.Tables)
+                var rows = new Dictionary<string, Row>();
+                foreach (var table in output.Tables)
                 {
-                    foreach (Row row in table.Rows)
+                    foreach (var row in table.Rows)
                     {
                         rows.Add(String.Concat(table.Name, ':', row.GetPrimaryKey('\t', " ")), row);
                     }
                 }
 
                 // process the _TransformView rows into transform rows
-                foreach (Row row in transformViewTable.Rows)
+                foreach (var row in transformViewTable.Rows)
                 {
-                    string tableName = (string)row[0];
-                    string columnName = (string)row[1];
-                    string primaryKeys = (string)row[2];
+                    var tableName = (string)row[0];
+                    var columnName = (string)row[1];
+                    var primaryKeys = (string)row[2];
 
-                    Table table = transform.EnsureTable(this.TableDefinitions[tableName]);
+                    var table = transform.EnsureTable(this.TableDefinitions[tableName]);
 
                     if ("CREATE" == columnName) // added table
                     {
@@ -185,7 +185,7 @@ namespace WixToolset.Core.WindowsInstaller.Unbind
                     }
                     else if ("DELETE" == columnName) // deleted row
                     {
-                        Row deletedRow = this.CreateRow(table, primaryKeys, false);
+                        var deletedRow = this.CreateRow(table, primaryKeys, false);
                         deletedRow.Operation = RowOperation.Delete;
                     }
                     else if ("DROP" == columnName) // dropped table
@@ -194,24 +194,24 @@ namespace WixToolset.Core.WindowsInstaller.Unbind
                     }
                     else if ("INSERT" == columnName) // added row
                     {
-                        string index = String.Concat(tableName, ':', primaryKeys);
-                        Row addedRow = (Row)rows[index];
+                        var index = String.Concat(tableName, ':', primaryKeys);
+                        var addedRow = rows[index];
                         addedRow.Operation = RowOperation.Add;
                         table.Rows.Add(addedRow);
                     }
                     else if (null != primaryKeys) // modified row
                     {
-                        string index = String.Concat(tableName, ':', primaryKeys);
+                        var index = String.Concat(tableName, ':', primaryKeys);
 
                         // the _TransformView table includes information for added rows
                         // that looks like modified rows so it sometimes needs to be ignored
-                        if (!addedRows.Contains(index))
+                        if (!addedRows.ContainsKey(index))
                         {
-                            Row modifiedRow = (Row)rows[index];
+                            var modifiedRow = rows[index];
 
                             // mark the field as modified
-                            int indexOfModifiedValue = -1;
-                            for (int i = 0; i < modifiedRow.TableDefinition.Columns.Length; ++i)
+                            var indexOfModifiedValue = -1;
+                            for (var i = 0; i < modifiedRow.TableDefinition.Columns.Length; ++i)
                             {
                                 if (columnName.Equals(modifiedRow.TableDefinition.Columns[i].Name, StringComparison.Ordinal))
                                 {
@@ -231,7 +231,7 @@ namespace WixToolset.Core.WindowsInstaller.Unbind
                     }
                     else // added column
                     {
-                        ColumnDefinition column = table.Definition.Columns.Single(c => c.Name.Equals(columnName, StringComparison.Ordinal));
+                        var column = table.Definition.Columns.Single(c => c.Name.Equals(columnName, StringComparison.Ordinal));
                         column.Added = true;
                     }
                 }
@@ -240,21 +240,6 @@ namespace WixToolset.Core.WindowsInstaller.Unbind
             return transform;
         }
 
-        private void GenerateDatabase(WindowsInstallerData output, string databaseFile)
-        {
-            var command = new GenerateDatabaseCommand();
-            command.Extensions = Array.Empty<IFileSystemExtension>();
-            command.Output = output;
-            command.OutputPath = databaseFile;
-            command.KeepAddedColumns = true;
-            command.UseSubDirectory = false;
-            command.SuppressAddingValidationRows = true;
-            command.TableDefinitions = this.TableDefinitions;
-            command.IntermediateFolder = this.IntermediateFolder;
-            command.Codepage = -1;
-            command.Execute();
-        }
-
         /// <summary>
         /// Create a deleted or modified row.
         /// </summary>
@@ -264,14 +249,14 @@ namespace WixToolset.Core.WindowsInstaller.Unbind
         /// <returns>The new row.</returns>
         private Row CreateRow(Table table, string primaryKeys, bool setRequiredFields)
         {
-            Row row = table.CreateRow(null);
+            var row = table.CreateRow(null);
 
-            string[] primaryKeyParts = primaryKeys.Split('\t');
-            int primaryKeyPartIndex = 0;
+            var primaryKeyParts = primaryKeys.Split('\t');
+            var primaryKeyPartIndex = 0;
 
-            for (int i = 0; i < table.Definition.Columns.Length; i++)
+            for (var i = 0; i < table.Definition.Columns.Length; i++)
             {
-                ColumnDefinition columnDefinition = table.Definition.Columns[i];
+                var columnDefinition = table.Definition.Columns[i];
 
                 if (columnDefinition.PrimaryKey)
                 {
@@ -294,8 +279,8 @@ namespace WixToolset.Core.WindowsInstaller.Unbind
                     {
                         if (null == this.EmptyFile)
                         {
-                            this.EmptyFile = Path.GetTempFileName() + ".empty";
-                            using (FileStream fileStream = File.Create(this.EmptyFile))
+                            this.EmptyFile = Path.Combine(this.IntermediateFolder, ".empty");
+                            using (var fileStream = File.Create(this.EmptyFile))
                             {
                             }
                         }
@@ -311,5 +296,11 @@ namespace WixToolset.Core.WindowsInstaller.Unbind
 
             return row;
         }
+
+        private void GenerateDatabase(WindowsInstallerData output, string databaseFile)
+        {
+            var command = new GenerateDatabaseCommand(this.Messaging, null, null, output, databaseFile, this.TableDefinitions, this.IntermediateFolder, codepage: -1, keepAddedColumns: true, suppressAddingValidationRows: true, useSubdirectory: false);
+            command.Execute();
+        }
     }
 }
diff --git a/src/WixToolset.Core.WindowsInstaller/WindowsInstallerBackendFactory.cs b/src/WixToolset.Core.WindowsInstaller/WindowsInstallerBackendFactory.cs
index 173404d7..f9cf4492 100644
--- a/src/WixToolset.Core.WindowsInstaller/WindowsInstallerBackendFactory.cs
+++ b/src/WixToolset.Core.WindowsInstaller/WindowsInstallerBackendFactory.cs
@@ -1,11 +1,10 @@
-// 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.
+// 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
 {
     using System;
     using System.IO;
     using WixToolset.Extensibility;
-    using WixToolset.Extensibility.Data;
 
     internal class WindowsInstallerBackendFactory : IBackendFactory
     {
@@ -16,7 +15,7 @@ namespace WixToolset.Core.WindowsInstaller
                 outputType = Path.GetExtension(outputFile);
             }
 
-            switch (outputType.ToLowerInvariant())
+            switch (outputType?.ToLowerInvariant())
             {
                 case "module":
                 case ".msm":
diff --git a/src/WixToolset.Core/Bind/FileFacade.cs b/src/WixToolset.Core/Bind/FileFacade.cs
index d631a3b5..7bfdb9bb 100644
--- a/src/WixToolset.Core/Bind/FileFacade.cs
+++ b/src/WixToolset.Core/Bind/FileFacade.cs
@@ -2,32 +2,146 @@
 
 namespace WixToolset.Core.Bind
 {
+    using System;
     using System.Collections.Generic;
+    using WixToolset.Data;
     using WixToolset.Data.Tuples;
+    using WixToolset.Data.WindowsInstaller;
+    using WixToolset.Data.WindowsInstaller.Rows;
 
     public class FileFacade
     {
         public FileFacade(FileTuple file, AssemblyTuple assembly)
         {
-            this.File = file;
-            this.Assembly = assembly;
+            this.FileTuple = file;
+            this.AssemblyTuple = assembly;
         }
 
         public FileFacade(bool fromModule, FileTuple file)
         {
             this.FromModule = fromModule;
-            this.File = file;
+            this.FileTuple = file;
+        }
+
+        internal FileFacade(FileRow row)
+        {
+            this.FromTransform = true;
+            this.FileRow = row;
         }
 
         public bool FromModule { get; }
 
-        public FileTuple File { get; }
+        public bool FromTransform { get; }
+
+        private FileRow FileRow { get; }
+
+        private FileTuple FileTuple { get; }
+
+        private AssemblyTuple AssemblyTuple { get; }
+
+        public string Id => this.FileRow == null ? this.FileTuple.Id.Id : this.FileRow.File;
+
+        public Identifier Identifier => this.FileRow == null ? this.FileTuple.Id : throw new NotImplementedException();
+
+        public string ComponentRef => this.FileRow == null ? this.FileTuple.ComponentRef : this.FileRow.Component;
+
+        public int DiskId
+        {
+            get => this.FileRow == null ? this.FileTuple.DiskId ?? 0 : this.FileRow.DiskId;
+            set
+            {
+                if (this.FileRow == null)
+                {
+                    this.FileTuple.DiskId = value;
+                }
+                else
+                {
+                    this.FileRow.DiskId = value;
+                }
+            }
+        }
+
+        public string FileName => this.FileRow == null ? this.FileTuple.Name : this.FileRow.FileName;
+
+        public int FileSize
+        {
+            get => this.FileRow == null ? this.FileTuple.FileSize : this.FileRow.FileSize;
+            set
+            {
+                if (this.FileRow == null)
+                {
+                    this.FileTuple.FileSize = value;
+                }
+                else
+                {
+                    this.FileRow.FileSize = value;
+                }
+            }
+        }
+
+        public string Language
+        {
+            get => this.FileRow == null ? this.FileTuple.Language : this.FileRow.Language;
+            set
+            {
+                if (this.FileRow == null)
+                {
+                    this.FileTuple.Language = value;
+                }
+                else
+                {
+                    this.FileRow.Language = value;
+                }
+            }
+        }
+
+        public int? PatchGroup => this.FileRow == null ? this.FileTuple.PatchGroup : null;
+
+        public int Sequence
+        {
+            get => this.FileRow == null ? this.FileTuple.Sequence : this.FileRow.Sequence;
+            set
+            {
+                if (this.FileRow == null)
+                {
+                    this.FileTuple.Sequence = value;
+                }
+                else
+                {
+                    this.FileRow.Sequence = value;
+                }
+            }
+        }
+
+        public SourceLineNumber SourceLineNumber => this.FileRow == null ? this.FileTuple.SourceLineNumbers : this.FileRow.SourceLineNumbers;
+
+        public string SourcePath => this.FileRow == null ? this.FileTuple.Source.Path : this.FileRow.Source;
+
+        public bool Compressed => this.FileRow == null ? (this.FileTuple.Attributes & FileTupleAttributes.Compressed) == FileTupleAttributes.Compressed : (this.FileRow.Attributes & WindowsInstallerConstants.MsidbFileAttributesCompressed) == WindowsInstallerConstants.MsidbFileAttributesCompressed;
+
+        public bool Uncompressed => this.FileRow == null ? (this.FileTuple.Attributes & FileTupleAttributes.Uncompressed) == FileTupleAttributes.Uncompressed : (this.FileRow.Attributes & WindowsInstallerConstants.MsidbFileAttributesNoncompressed) == WindowsInstallerConstants.MsidbFileAttributesNoncompressed;
+
+        public string Version
+        {
+            get => this.FileRow == null ? this.FileTuple.Version : this.FileRow.Version;
+            set
+            {
+                if (this.FileRow == null)
+                {
+                    this.FileTuple.Version = value;
+                }
+                else
+                {
+                    this.FileRow.Version = value;
+                }
+            }
+        }
 
-        public AssemblyTuple Assembly { get; }
+        public AssemblyType? AssemblyType => this.FileRow == null ? this.AssemblyTuple?.Type : throw new NotImplementedException();
 
-        public int DiskId => this.File.DiskId ?? 0;
+        public string AssemblyApplicationFileRef => this.FileRow == null ? this.AssemblyTuple?.ApplicationFileRef : throw new NotImplementedException();
 
-        public bool Uncompressed => (this.File.Attributes & FileTupleAttributes.Uncompressed) == FileTupleAttributes.Uncompressed;
+        public string AssemblyManifestFileRef => this.FileRow == null ? this.AssemblyTuple?.ManifestFileRef : throw new NotImplementedException();
 
         /// <summary>
         /// Gets the set of MsiAssemblyName rows created for this file.
diff --git a/src/WixToolset.Core/Bind/ResolveFieldsCommand.cs b/src/WixToolset.Core/Bind/ResolveFieldsCommand.cs
index 19a26915..5cb2524d 100644
--- a/src/WixToolset.Core/Bind/ResolveFieldsCommand.cs
+++ b/src/WixToolset.Core/Bind/ResolveFieldsCommand.cs
@@ -89,7 +89,7 @@ namespace WixToolset.Core.Bind
                         {
                             var objectField = field.AsPath();
 
-#if REVISIT_FOR_PATCHING
+#if TODO_PATCHING
                             // Skip file resolution if the file is to be deleted.
                             if (RowOperation.Delete == tuple.Operation)
                             {
@@ -111,7 +111,7 @@ namespace WixToolset.Core.Bind
                                 {
                                     if (!this.BuildingPatch) // Normal binding for non-Patch scenario such as link (light.exe)
                                     {
-#if REVISIT_FOR_PATCHING
+#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)
                                         {
@@ -129,7 +129,7 @@ namespace WixToolset.Core.Bind
                                         var value = fileResolver.ResolveFile(objectField.Path, tuple.Definition, tuple.SourceLineNumbers, BindStage.Normal);
                                         field.Set(value);
                                     }
-#if REVISIT_FOR_PATCHING
+#if TODO_PATCHING
                                     else // Re-base binding path scenario caused by pyro.exe -bt -bu
                                     {
                                         // by default, use the resolved Data for file lookup
@@ -158,7 +158,7 @@ namespace WixToolset.Core.Bind
                                 }
                             }
 
-#if REVISIT_FOR_PATCHING
+#if TODO_PATCHING
                             if (null != objectField.PreviousData)
                             {
                                 objectField.PreviousData = this.BindVariableResolver.ResolveVariables(tuple.SourceLineNumbers, objectField.PreviousData, false, out isDefault);
diff --git a/src/WixToolset.Core/Compiler.cs b/src/WixToolset.Core/Compiler.cs
index 0c3d4c9c..cee64911 100644
--- a/src/WixToolset.Core/Compiler.cs
+++ b/src/WixToolset.Core/Compiler.cs
@@ -7878,7 +7878,7 @@ namespace WixToolset.Core
             if (patch)
             {
                 // /Patch/PatchProperty goes directly into MsiPatchMetadata table
-                this.Core.AddTuple(new MsiPatchMetadataTuple(sourceLineNumbers)
+                this.Core.AddTuple(new MsiPatchMetadataTuple(sourceLineNumbers, new Identifier(AccessModifier.Public, company, name))
                 {
                     Company = company,
                     Property = name,
@@ -8130,12 +8130,15 @@ namespace WixToolset.Core
         /// </summary>
         /// <param name="node">The element to parse.</param>
         /// <param name="diskId">Media index from parent element.</param>
-        private void ParsePatchBaselineElement(XElement node, int diskId)
+        private void ParsePatchBaselineElement(XElement node, int? diskId)
         {
             var sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
             Identifier id = null;
             var parsedValidate = false;
             var validationFlags = TransformFlags.PatchTransformDefault;
+            string baselineFile = null;
+            string updateFile = null;
+            string transformFile = null;
 
             foreach (var attrib in node.Attributes())
             {
@@ -8146,6 +8149,18 @@ namespace WixToolset.Core
                     case "Id":
                         id = this.Core.GetAttributeIdentifier(sourceLineNumbers, attrib);
                         break;
+                    case "DiskId":
+                        diskId = this.Core.GetAttributeIntegerValue(sourceLineNumbers, attrib, 1, Int16.MaxValue);
+                        break;
+                    case "BaselineFile":
+                        baselineFile = this.Core.GetAttributeValue(sourceLineNumbers, attrib);
+                        break;
+                    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;
@@ -8167,6 +8182,28 @@ namespace WixToolset.Core
                 this.Core.Write(ErrorMessages.IdentifierTooLongError(sourceLineNumbers, node.Name.LocalName, "Id", id.Id, 27));
             }
 
+            if (!String.IsNullOrEmpty(baselineFile) || !String.IsNullOrEmpty(updateFile))
+            {
+                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"));
+                }
+            }
+            else if (String.IsNullOrEmpty(transformFile))
+            {
+                this.Core.Write(ErrorMessages.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "BaselineFile", "TransformFile", true));
+            }
+
             foreach (var child in node.Elements())
             {
                 if (CompilerCore.WixNamespace == child.Name.Namespace)
@@ -8200,8 +8237,11 @@ namespace WixToolset.Core
             {
                 var tuple = new WixPatchBaselineTuple(sourceLineNumbers, id)
                 {
-                    DiskId = diskId,
-                    ValidationFlags = validationFlags
+                    DiskId = diskId ?? 1,
+                    ValidationFlags = validationFlags,
+                    BaselineFile = new IntermediateFieldPathValue { Path = baselineFile },
+                    UpdateFile = new IntermediateFieldPathValue { Path = updateFile },
+                    TransformFile = new IntermediateFieldPathValue { Path = transformFile }
                 };
 
                 this.Core.AddTuple(tuple);
diff --git a/src/WixToolset.Core/Compiler_2.cs b/src/WixToolset.Core/Compiler_2.cs
index 4b6839f1..89d4b6da 100644
--- a/src/WixToolset.Core/Compiler_2.cs
+++ b/src/WixToolset.Core/Compiler_2.cs
@@ -1030,12 +1030,6 @@ namespace WixToolset.Core
 
                 this.Core.AddTuple(new SummaryInformationTuple(sourceLineNumbers)
                 {
-                    PropertyId = SumaryInformationType.WindowsInstallerVersion,
-                    Value = msiVersion.ToString(CultureInfo.InvariantCulture)
-                });
-
-                this.Core.AddTuple(new SummaryInformationTuple(sourceLineNumbers)
-                {
                     PropertyId = SumaryInformationType.Security,
                     Value = YesNoDefaultType.No == security ? "0" : YesNoDefaultType.Yes == security ? "4" : "2"
                 });
diff --git a/src/WixToolset.Core/Compiler_Patch.cs b/src/WixToolset.Core/Compiler_Patch.cs
index 42951543..f8d05132 100644
--- a/src/WixToolset.Core/Compiler_Patch.cs
+++ b/src/WixToolset.Core/Compiler_Patch.cs
@@ -197,9 +197,8 @@ namespace WixToolset.Core
 
             if (!this.Core.EncounteredError)
             {
-                var tuple = new WixPatchIdTuple(sourceLineNumbers)
+                var tuple = new WixPatchIdTuple(sourceLineNumbers, new Identifier(AccessModifier.Public, patchId))
                 {
-                    ProductCode = patchId,
                     ClientPatchId = clientPatchId,
                     OptimizePatchSizeForLargeFiles = optimizePatchSizeForLargeFiles,
                     ApiPatchingSymbolFlags = apiPatchingSymbolFlags
diff --git a/src/WixToolset.Core/Compiler_UI.cs b/src/WixToolset.Core/Compiler_UI.cs
index 30bb7ab6..8a425fd4 100644
--- a/src/WixToolset.Core/Compiler_UI.cs
+++ b/src/WixToolset.Core/Compiler_UI.cs
@@ -470,7 +470,7 @@ namespace WixToolset.Core
                         string defaultControl = null;
                         string cancelControl = null;
 
-                        this.ParseControlElement(child, id.Id, TupleDefinitionType.BBControl, ref lastTabRow, ref firstControl, ref defaultControl, ref cancelControl, false);
+                        this.ParseControlElement(child, id.Id, TupleDefinitionType.BBControl, ref lastTabRow, ref firstControl, ref defaultControl, ref cancelControl);
                         break;
                     default:
                         this.Core.UnexpectedElement(node, child);
@@ -966,7 +966,7 @@ namespace WixToolset.Core
                     switch (child.Name.LocalName)
                     {
                     case "Control":
-                        this.ParseControlElement(child, id.Id, TupleDefinitionType.Control, ref lastTabRow, ref firstControl, ref defaultControl, ref cancelControl, trackDiskSpace);
+                        this.ParseControlElement(child, id.Id, TupleDefinitionType.Control, ref lastTabRow, ref firstControl, ref defaultControl, ref cancelControl);
                         break;
                     default:
                         this.Core.UnexpectedElement(node, child);
@@ -1032,7 +1032,7 @@ namespace WixToolset.Core
         /// <param name="defaultControl">Name of the default control.</param>
         /// <param name="cancelControl">Name of the candle control.</param>
         /// <param name="trackDiskSpace">True if the containing dialog tracks disk space.</param>
-        private void ParseControlElement(XElement node, string dialog, TupleDefinitionType tupleType, ref IntermediateTuple lastTabTuple, ref string firstControl, ref string defaultControl, ref string cancelControl, bool trackDiskSpace)
+        private void ParseControlElement(XElement node, string dialog, TupleDefinitionType tupleType, ref IntermediateTuple lastTabTuple, ref string firstControl, ref string defaultControl, ref string cancelControl)
         {
             var sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
             Identifier controlId = null;
diff --git a/src/WixToolset.Core/Resolver.cs b/src/WixToolset.Core/Resolver.cs
index cbae3742..54bde848 100644
--- a/src/WixToolset.Core/Resolver.cs
+++ b/src/WixToolset.Core/Resolver.cs
@@ -92,7 +92,7 @@ namespace WixToolset.Core
                 delayedFields = command.DelayedFields;
             }
 
-#if REVISIT_FOR_PATCHING
+#if TODO_PATCHING
             if (context.IntermediateRepresentation.SubStorages != null)
             {
                 foreach (SubStorage transform in context.IntermediateRepresentation.SubStorages)
diff --git a/src/test/WixToolsetTest.CoreIntegration/PatchFixture.cs b/src/test/WixToolsetTest.CoreIntegration/PatchFixture.cs
new file mode 100644
index 00000000..584f86fe
--- /dev/null
+++ b/src/test/WixToolsetTest.CoreIntegration/PatchFixture.cs
@@ -0,0 +1,112 @@
+// 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 WixToolsetTest.CoreIntegration
+{
+    using System.ComponentModel;
+    using System.IO;
+    using System.Linq;
+    using System.Runtime.InteropServices;
+    using System.Text;
+    using System.Xml.Linq;
+    using WixBuildTools.TestSupport;
+    using WixToolset.Core.TestPackage;
+    using Xunit;
+
+    public class PatchFixture
+    {
+        private static readonly XNamespace PatchNamespace = "http://www.microsoft.com/msi/patch_applicability.xsd";
+
+        [Fact(Skip = "Skip until patches have files in them")]
+        public void CanBuildSimplePatch()
+        {
+            var folder = TestData.Get(@"TestData\PatchSingle");
+
+            using (var fs = new DisposableFileSystem())
+            {
+                var tempFolder = fs.GetFolder();
+
+                var baselinePdb = BuildMsi("Baseline.msi", folder, tempFolder, "1.0.0", "1.0.0", "1.0.0");
+                var update1Pdb = BuildMsi("Update.msi", folder, tempFolder, "1.0.1", "1.0.1", "1.0.1");
+                var patchPdb = BuildMsp("Patch1.msp", folder, tempFolder, "1.0.1");
+                var baselinePath = Path.ChangeExtension(baselinePdb, ".msp");
+                var patchPath = Path.ChangeExtension(patchPdb, ".msp");
+
+                Assert.True(File.Exists(baselinePdb));
+                Assert.True(File.Exists(update1Pdb));
+
+                var doc = GetExtractPatchXml(patchPath);
+                Assert.Equal("{7D326855-E790-4A94-8611-5351F8321FCA}", doc.Root.Element(PatchNamespace + "TargetProductCode").Value);
+
+                var names = Query.GetSubStorageNames(patchPath);
+                Assert.Equal(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.Equal(new[] { "a", "b" }, files.Select(f => f.ArchiveName).ToArray()); // This test may not be quite correct, yet.
+            }
+        }
+
+        private static string BuildMsi(string outputName, string sourceFolder, string baseFolder, string defineV, string defineA, string defineB)
+        {
+            var outputPath = Path.Combine(baseFolder, Path.Combine("bin", outputName));
+
+            var result = WixRunner.Execute(new[]
+            {
+                "build",
+                Path.Combine(sourceFolder, @"Package.wxs"),
+                "-d", "V=" + defineV,
+                "-d", "A=" + defineA,
+                "-d", "B=" + defineB,
+                "-bindpath", Path.Combine(sourceFolder, ".data"),
+                "-intermediateFolder", Path.Combine(baseFolder, "obj"),
+                "-o", outputPath
+            });
+
+            result.AssertSuccess();
+
+            return Path.ChangeExtension(outputPath, ".wixpdb");
+        }
+
+        private static string BuildMsp(string outputName, string sourceFolder, string baseFolder, string defineV)
+        {
+            var outputPath = Path.Combine(baseFolder, Path.Combine("bin", outputName));
+
+            var result = WixRunner.Execute(new[]
+            {
+                "build",
+                Path.Combine(sourceFolder, @"Patch.wxs"),
+                "-d", "V=" + defineV,
+                "-bindpath", Path.Combine(baseFolder, "bin"),
+                "-intermediateFolder", Path.Combine(baseFolder, "obj"),
+                "-o", outputPath
+            });
+
+            result.AssertSuccess();
+
+            return Path.ChangeExtension(outputPath, ".wixpdb");
+        }
+
+        private static XDocument GetExtractPatchXml(string path)
+        {
+            var buffer = new StringBuilder(65535);
+            var size = buffer.Capacity;
+
+            var er = MsiExtractPatchXMLData(path, 0, buffer, ref size);
+            if (er != 0)
+            {
+                throw new Win32Exception(er);
+            }
+
+            return XDocument.Parse(buffer.ToString());
+        }
+
+        [DllImport("msi.dll", EntryPoint = "MsiExtractPatchXMLDataW", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        private static extern int MsiExtractPatchXMLData(string szPatchPath, int dwReserved, StringBuilder szXMLData, ref int pcchXMLData);
+
+        [DllImport("msi.dll", EntryPoint = "MsiApplyPatchW", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        private static extern int MsiApplyPatch(string szPatchPackage, string szInstallPackage, int eInstallType, string szCommandLine);
+    }
+}
diff --git a/src/test/WixToolsetTest.CoreIntegration/PreprocessorFixture.cs b/src/test/WixToolsetTest.CoreIntegration/PreprocessorFixture.cs
index 4e48cbe1..b1a4c607 100644
--- a/src/test/WixToolsetTest.CoreIntegration/PreprocessorFixture.cs
+++ b/src/test/WixToolsetTest.CoreIntegration/PreprocessorFixture.cs
@@ -68,34 +68,6 @@ namespace WixToolsetTest.CoreIntegration
         }
 
         [Fact]
-        public void WixVersionVariablesWork()
-        {
-            var folder = TestData.Get(@"TestData\Variables");
-
-            using (var fs = new DisposableFileSystem())
-            {
-                var baseFolder = fs.GetFolder();
-                var intermediateFolder = Path.Combine(baseFolder, "obj");
-
-                var result = WixRunner.Execute(new[]
-                {
-                    "build",
-                    Path.Combine(folder, "Package.wxs"),
-                    Path.Combine(folder, "PackageComponents.wxs"),
-                    "-loc", Path.Combine(folder, "Package.en-us.wxl"),
-                    "-bindpath", Path.Combine(folder, "data"),
-                    "-intermediateFolder", intermediateFolder,
-                    "-o", Path.Combine(baseFolder, @"bin\test.msi")
-                });
-
-                result.AssertSuccess();
-
-                var warning = result.Messages.Where(message => message.Id == (int)WarningMessages.Ids.PreprocessorWarning);
-                Assert.Single(warning);
-            }
-        }
-
-        [Fact]
         public void ForEachLoopsWork()
         {
             var folder = TestData.Get(@"TestData\ForEach");
diff --git a/src/test/WixToolsetTest.CoreIntegration/TestData/PatchFamilyFilter/.data/Av1.0.0.txt b/src/test/WixToolsetTest.CoreIntegration/TestData/PatchFamilyFilter/.data/Av1.0.0.txt
new file mode 100644
index 00000000..6fd385bd
--- /dev/null
+++ b/src/test/WixToolsetTest.CoreIntegration/TestData/PatchFamilyFilter/.data/Av1.0.0.txt
@@ -0,0 +1 @@
+This is A v1.0.0
diff --git a/src/test/WixToolsetTest.CoreIntegration/TestData/PatchFamilyFilter/.data/Av1.0.1.txt b/src/test/WixToolsetTest.CoreIntegration/TestData/PatchFamilyFilter/.data/Av1.0.1.txt
new file mode 100644
index 00000000..b1f0bc01
--- /dev/null
+++ b/src/test/WixToolsetTest.CoreIntegration/TestData/PatchFamilyFilter/.data/Av1.0.1.txt
@@ -0,0 +1 @@
+This ia A v1.0.1
diff --git a/src/test/WixToolsetTest.CoreIntegration/TestData/PatchFamilyFilter/.data/Bv1.0.0.txt b/src/test/WixToolsetTest.CoreIntegration/TestData/PatchFamilyFilter/.data/Bv1.0.0.txt
new file mode 100644
index 00000000..ece55fec
--- /dev/null
+++ b/src/test/WixToolsetTest.CoreIntegration/TestData/PatchFamilyFilter/.data/Bv1.0.0.txt
@@ -0,0 +1 @@
+This is B v1.0.0
diff --git a/src/test/WixToolsetTest.CoreIntegration/TestData/PatchFamilyFilter/.data/Bv1.0.1.txt b/src/test/WixToolsetTest.CoreIntegration/TestData/PatchFamilyFilter/.data/Bv1.0.1.txt
new file mode 100644
index 00000000..cf3372fd
--- /dev/null
+++ b/src/test/WixToolsetTest.CoreIntegration/TestData/PatchFamilyFilter/.data/Bv1.0.1.txt
@@ -0,0 +1 @@
+This ia B v1.0.1
diff --git a/src/test/WixToolsetTest.CoreIntegration/TestData/PatchFamilyFilter/Package.wxs b/src/test/WixToolsetTest.CoreIntegration/TestData/PatchFamilyFilter/Package.wxs
new file mode 100644
index 00000000..2657797f
--- /dev/null
+++ b/src/test/WixToolsetTest.CoreIntegration/TestData/PatchFamilyFilter/Package.wxs
@@ -0,0 +1,31 @@
+<Wix xmlns='http://schemas.microsoft.com/wix/2006/wi'>
+  <Product Id='e703bf17-4765-444c-91fd-88550fa681d4' Name='~Test Package'
+            Version='$(var.V)' Manufacturer='Example Corporation' Language='1033'
+            UpgradeCode='e703bf17-4765-444c-91fd-88550fa681d4'>
+    <Package InstallScope='perMachine' />
+
+    <MajorUpgrade DowngradeErrorMessage='Newer version already installed.' />
+    <MediaTemplate />
+
+    <Directory Id='TARGETDIR' Name='SourceDir'>
+      <Directory Id='ProgramFilesFolder'>
+        <Directory Id='INSTALLFOLDER' Name='~Test App' />
+      </Directory>
+    </Directory>
+
+    <Feature Id='Main'>
+      <ComponentGroupRef Id='Components' />
+    </Feature>
+  </Product>
+
+  <Fragment>
+    <ComponentGroup Id="Components" Directory='INSTALLFOLDER'>
+      <Component Id='A'>
+        <File Name='a.txt' Source='Av$(var.A).txt' />
+      </Component>
+      <Component Id='B'>
+        <File Name='b.txt' Source='Bv$(var.B).txt' />
+      </Component>
+    </ComponentGroup>
+  </Fragment>
+</Wix>
diff --git a/src/test/WixToolsetTest.CoreIntegration/TestData/PatchFamilyFilter/Patch.wxs b/src/test/WixToolsetTest.CoreIntegration/TestData/PatchFamilyFilter/Patch.wxs
new file mode 100644
index 00000000..7c3cff7e
--- /dev/null
+++ b/src/test/WixToolsetTest.CoreIntegration/TestData/PatchFamilyFilter/Patch.wxs
@@ -0,0 +1,23 @@
+<Wix xmlns="http://schemas.microsoft.com/wix/2006/wi">
+  <Patch
+    AllowRemoval="yes"
+    Manufacturer="FireGiant"
+    MoreInfoURL="http://www.example.com/"
+    DisplayName="~Test Patch v$(var.V)"
+    Description="~Test Small Update Patch v($var.V)"
+    Classification="Update"
+    >
+
+    <Media Id="1" Cabinet="foo.cab">
+      <PatchBaseline Id="RTM"/>
+    </Media>
+
+    <PatchFamilyRef Id='SamplePatchFamily'/>
+  </Patch>
+
+  <Fragment>
+    <PatchFamily Id='SamplePatchFamily' Version='$(var.V)' Supersede='yes'>
+      <ComponentRef Id="A"/>
+    </PatchFamily>
+  </Fragment>
+</Wix>
diff --git a/src/test/WixToolsetTest.CoreIntegration/TestData/PatchSingle/.data/Av1.0.0.txt b/src/test/WixToolsetTest.CoreIntegration/TestData/PatchSingle/.data/Av1.0.0.txt
new file mode 100644
index 00000000..6fd385bd
--- /dev/null
+++ b/src/test/WixToolsetTest.CoreIntegration/TestData/PatchSingle/.data/Av1.0.0.txt
@@ -0,0 +1 @@
+This is A v1.0.0
diff --git a/src/test/WixToolsetTest.CoreIntegration/TestData/PatchSingle/.data/Av1.0.1.txt b/src/test/WixToolsetTest.CoreIntegration/TestData/PatchSingle/.data/Av1.0.1.txt
new file mode 100644
index 00000000..b1f0bc01
--- /dev/null
+++ b/src/test/WixToolsetTest.CoreIntegration/TestData/PatchSingle/.data/Av1.0.1.txt
@@ -0,0 +1 @@
+This ia A v1.0.1
diff --git a/src/test/WixToolsetTest.CoreIntegration/TestData/PatchSingle/.data/Bv1.0.0.txt b/src/test/WixToolsetTest.CoreIntegration/TestData/PatchSingle/.data/Bv1.0.0.txt
new file mode 100644
index 00000000..ece55fec
--- /dev/null
+++ b/src/test/WixToolsetTest.CoreIntegration/TestData/PatchSingle/.data/Bv1.0.0.txt
@@ -0,0 +1 @@
+This is B v1.0.0
diff --git a/src/test/WixToolsetTest.CoreIntegration/TestData/PatchSingle/.data/Bv1.0.1.txt b/src/test/WixToolsetTest.CoreIntegration/TestData/PatchSingle/.data/Bv1.0.1.txt
new file mode 100644
index 00000000..cf3372fd
--- /dev/null
+++ b/src/test/WixToolsetTest.CoreIntegration/TestData/PatchSingle/.data/Bv1.0.1.txt
@@ -0,0 +1 @@
+This ia B v1.0.1
diff --git a/src/test/WixToolsetTest.CoreIntegration/TestData/PatchSingle/Package.wxs b/src/test/WixToolsetTest.CoreIntegration/TestData/PatchSingle/Package.wxs
new file mode 100644
index 00000000..ee133ba3
--- /dev/null
+++ b/src/test/WixToolsetTest.CoreIntegration/TestData/PatchSingle/Package.wxs
@@ -0,0 +1,31 @@
+<Wix xmlns='http://wixtoolset.org/schemas/v4/wxs'>
+  <Product Id='7d326855-e790-4a94-8611-5351f8321fca' Name='~Test Package'
+            Version='$(var.V)' Manufacturer='Example Corporation' Language='1033'
+            UpgradeCode='7d326855-e790-4a94-8611-5351f8321fca'>
+    <Package InstallScope='perMachine' Compressed='yes' />
+
+    <MajorUpgrade DowngradeErrorMessage='Newer version already installed.' />
+    <MediaTemplate EmbedCab='yes' />
+
+    <Directory Id='TARGETDIR' Name='SourceDir'>
+      <Directory Id='ProgramFilesFolder'>
+        <Directory Id='INSTALLFOLDER' Name='~Test App' />
+      </Directory>
+    </Directory>
+
+    <Feature Id='Main'>
+      <ComponentGroupRef Id='Components' />
+    </Feature>
+  </Product>
+
+  <Fragment>
+    <ComponentGroup Id="Components" Directory='INSTALLFOLDER'>
+      <Component>
+        <File Id='a.txt' Name='a.txt' Source='Av$(var.A).txt' />
+      </Component>
+      <Component>
+        <File Id='b.txt' Name='b.txt' Source='Bv$(var.B).txt' />
+      </Component>
+    </ComponentGroup>
+  </Fragment>
+</Wix>
diff --git a/src/test/WixToolsetTest.CoreIntegration/TestData/PatchSingle/Patch.wxs b/src/test/WixToolsetTest.CoreIntegration/TestData/PatchSingle/Patch.wxs
new file mode 100644
index 00000000..52e87f64
--- /dev/null
+++ b/src/test/WixToolsetTest.CoreIntegration/TestData/PatchSingle/Patch.wxs
@@ -0,0 +1,16 @@
+<Wix xmlns='http://wixtoolset.org/schemas/v4/wxs'>
+    <Patch
+    AllowRemoval="yes"
+    DisplayName="~Test Patch v$(var.V)"
+    Description="~Test Small Update Patch v$(var.V)"
+    MoreInfoURL="http://www.example.com/"
+    Manufacturer="Example Corporation"
+    Classification="Update">
+
+    <Media Id="1" Cabinet="foo.cab">
+      <PatchBaseline Id="RTM" BaselineFile="Baseline.wixpdb" UpdateFile="Update.wixpdb" />
+    </Media>
+
+    <PatchFamily Id='SequenceFamily' Version='$(var.V)' />
+  </Patch>
+</Wix>
diff --git a/src/test/WixToolsetTest.CoreIntegration/WixToolsetTest.CoreIntegration.csproj b/src/test/WixToolsetTest.CoreIntegration/WixToolsetTest.CoreIntegration.csproj
index 0330adf6..b17a27ff 100644
--- a/src/test/WixToolsetTest.CoreIntegration/WixToolsetTest.CoreIntegration.csproj
+++ b/src/test/WixToolsetTest.CoreIntegration/WixToolsetTest.CoreIntegration.csproj
@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <!-- 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. -->
 
 <Project Sdk="Microsoft.NET.Sdk">
@@ -41,6 +41,18 @@
     <Content Include="TestData\Font\TrueType.wxs" CopyToOutputDirectory="PreserveNewest" />
     <Content Include="TestData\Icon\SampleIcon.wxs" CopyToOutputDirectory="PreserveNewest" />
     <Content Include="TestData\LockPermissions\EmptyPermissions.wxs" CopyToOutputDirectory="PreserveNewest" />
+    <Content Include="TestData\PatchFamilyFilter\.data\Av1.0.0.txt" CopyToOutputDirectory="PreserveNewest" />
+    <Content Include="TestData\PatchFamilyFilter\.data\Av1.0.1.txt" CopyToOutputDirectory="PreserveNewest" />
+    <Content Include="TestData\PatchFamilyFilter\.data\Bv1.0.0.txt" CopyToOutputDirectory="PreserveNewest" />
+    <Content Include="TestData\PatchFamilyFilter\.data\Bv1.0.1.txt" CopyToOutputDirectory="PreserveNewest" />
+    <Content Include="TestData\PatchFamilyFilter\Package.wxs" CopyToOutputDirectory="PreserveNewest" />
+    <Content Include="TestData\PatchFamilyFilter\Patch.wxs" CopyToOutputDirectory="PreserveNewest" />
+    <Content Include="TestData\PatchSingle\.data\Av1.0.0.txt" CopyToOutputDirectory="PreserveNewest" />
+    <Content Include="TestData\PatchSingle\.data\Av1.0.1.txt" CopyToOutputDirectory="PreserveNewest" />
+    <Content Include="TestData\PatchSingle\.data\Bv1.0.0.txt" CopyToOutputDirectory="PreserveNewest" />
+    <Content Include="TestData\PatchSingle\.data\Bv1.0.1.txt" CopyToOutputDirectory="PreserveNewest" />
+    <Content Include="TestData\PatchSingle\Package.wxs" CopyToOutputDirectory="PreserveNewest" />
+    <Content Include="TestData\PatchSingle\Patch.wxs" CopyToOutputDirectory="PreserveNewest" />
     <Content Include="TestData\SameFileFolders\data\a\test.txt" CopyToOutputDirectory="PreserveNewest" />
     <Content Include="TestData\SameFileFolders\data\c\test.txt" CopyToOutputDirectory="PreserveNewest" />
     <Content Include="TestData\SameFileFolders\data\b\test.txt" CopyToOutputDirectory="PreserveNewest" />