Massive refactoring to introduce the concept of IBackend

127 files changed, 4269 insertions, 2917 deletions

diff --git a/src/WixToolset.BuildTasks/WixToolset.BuildTasks.csproj b/src/WixToolset.BuildTasks/WixToolset.BuildTasks.csproj
index 10dce157..c34b3bca 100644
--- a/src/WixToolset.BuildTasks/WixToolset.BuildTasks.csproj
+++ b/src/WixToolset.BuildTasks/WixToolset.BuildTasks.csproj
@@ -24,6 +24,8 @@
 
   <ItemGroup>
     <ProjectReference Include="..\WixToolset.Core\WixToolset.Core.csproj" />
+    <ProjectReference Include="..\WixToolset.Core.Burn\WixToolset.Core.Burn.csproj" />
+    <ProjectReference Include="..\WixToolset.Core.WindowsInstaller\WixToolset.Core.WindowsInstaller.csproj" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/src/WixToolset.Core.Burn/BackendFactory.cs b/src/WixToolset.Core.Burn/BackendFactory.cs
new file mode 100644
index 00000000..042fa254
--- /dev/null
+++ b/src/WixToolset.Core.Burn/BackendFactory.cs
@@ -0,0 +1,30 @@
+// 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.Burn
+{
+    using System;
+    using System.IO;
+    using WixToolset.Extensibility;
+
+    internal class BackendFactory : IBackendFactory
+    {
+        public bool TryCreateBackend(string outputType, string outputFile, IBindContext context, out IBackend backend)
+        {
+            if (String.IsNullOrEmpty(outputType))
+            {
+                outputType = Path.GetExtension(outputFile);
+            }
+
+            switch (outputType.ToLowerInvariant())
+            {
+                case "bundle":
+                case ".exe":
+                    backend = new BundleBackend();
+                    return true;
+            }
+
+            backend = null;
+            return false;
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Bind/BindBundleCommand.cs b/src/WixToolset.Core.Burn/Bind/BindBundleCommand.cs
index 7ea0c830..212b1e81 100644
--- a/src/WixToolset.Core/Bind/BindBundleCommand.cs
+++ b/src/WixToolset.Core.Burn/Bind/BindBundleCommand.cs
@@ -1,6 +1,6 @@
 // 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.Bind
+namespace WixToolset.Core.Burn
 {
     using System;
     using System.Collections.Generic;
@@ -9,23 +9,83 @@ namespace WixToolset.Bind
     using System.IO;
     using System.Linq;
     using System.Reflection;
-    using WixToolset.Bind.Bundles;
+    using WixToolset.Bind;
+    using WixToolset.Core.Bind;
+    using WixToolset.Core.Burn.Bundles;
     using WixToolset.Data;
+    using WixToolset.Data.Bind;
     using WixToolset.Data.Rows;
     using WixToolset.Extensibility;
 
+    // TODO: (4.0) Refactor so that these don't need to be copied.
+    // Copied verbatim from ext\UtilExtension\wixext\UtilCompiler.cs
+    [Flags]
+    internal enum WixFileSearchAttributes
+    {
+        Default = 0x001,
+        MinVersionInclusive = 0x002,
+        MaxVersionInclusive = 0x004,
+        MinSizeInclusive = 0x008,
+        MaxSizeInclusive = 0x010,
+        MinDateInclusive = 0x020,
+        MaxDateInclusive = 0x040,
+        WantVersion = 0x080,
+        WantExists = 0x100,
+        IsDirectory = 0x200,
+    }
+
+    [Flags]
+    internal enum WixRegistrySearchAttributes
+    {
+        Raw = 0x01,
+        Compatible = 0x02,
+        ExpandEnvironmentVariables = 0x04,
+        WantValue = 0x08,
+        WantExists = 0x10,
+        Win64 = 0x20,
+    }
+
+    internal enum WixComponentSearchAttributes
+    {
+        KeyPath = 0x1,
+        State = 0x2,
+        WantDirectory = 0x4,
+    }
+
+    [Flags]
+    internal enum WixProductSearchAttributes
+    {
+        Version = 0x1,
+        Language = 0x2,
+        State = 0x4,
+        Assignment = 0x8,
+        UpgradeCode = 0x10,
+    }
+
     /// <summary>
     /// Binds a this.bundle.
     /// </summary>
-    internal class BindBundleCommand : ICommand
+    internal class BindBundleCommand
     {
+        public BindBundleCommand(IBindContext context)
+        {
+            this.TableDefinitions = WindowsInstallerStandard.GetTableDefinitions();
+
+            this.DelayedFields = context.DelayedFields;
+            this.ExpectedEmbeddedFiles = context.ExpectedEmbeddedFiles;
+
+            this.BackendExtensions = context.ExtensionManager.Create<IBurnBackendExtension>();
+        }
+
         public CompressionLevel DefaultCompressionLevel { private get; set; }
 
-        public IEnumerable<IBinderExtension> Extensions { private get; set; }
+        public IEnumerable<IDelayedField> DelayedFields { get; }
+
+        public IEnumerable<IExpectedExtractFile> ExpectedEmbeddedFiles { get; }
 
-        public BinderFileManagerCore FileManagerCore { private get; set; }
+        private IEnumerable<IBurnBackendExtension> BackendExtensions { get; }
 
-        public IEnumerable<IBinderFileManager> FileManagers { private get; set; }
+        public IEnumerable<IBinderExtension> Extensions { private get; set; }
 
         public Output Output { private get; set; }
 
@@ -35,9 +95,9 @@ namespace WixToolset.Bind
 
         public TableDefinitionCollection TableDefinitions { private get; set; }
 
-        public string TempFilesLocation { private get; set; }
+        public string IntermediateFolder { private get; set; }
 
-        public WixVariableResolver WixVariableResolver { private get; set; }
+        public IBindVariableResolver WixVariableResolver { private get; set; }
 
         public IEnumerable<FileTransfer> FileTransfers { get; private set; }
 
@@ -79,32 +139,9 @@ namespace WixToolset.Bind
                 return;
             }
 
-            // Localize fields, resolve wix variables, and resolve file paths.
-            ExtractEmbeddedFiles filesWithEmbeddedFiles = new ExtractEmbeddedFiles();
-
-            IEnumerable<DelayedField> delayedFields;
-            {
-                ResolveFieldsCommand command = new ResolveFieldsCommand();
-                command.Tables = this.Output.Tables;
-                command.FilesWithEmbeddedFiles = filesWithEmbeddedFiles;
-                command.FileManagerCore = this.FileManagerCore;
-                command.FileManagers = this.FileManagers;
-                command.SupportDelayedResolution = true;
-                command.TempFilesLocation = this.TempFilesLocation;
-                command.WixVariableResolver = this.WixVariableResolver;
-                command.Execute();
-
-                delayedFields = command.DelayedFields;
-            }
-
-            if (Messaging.Instance.EncounteredError)
-            {
-                return;
-            }
-
             // If there are any fields to resolve later, create the cache to populate during bind.
             IDictionary<string, string> variableCache = null;
-            if (delayedFields.Any())
+            if (this.DelayedFields.Any())
             {
                 variableCache = new Dictionary<string, string>(StringComparer.InvariantCultureIgnoreCase);
             }
@@ -116,8 +153,8 @@ namespace WixToolset.Bind
 
             // Extract files that come from cabinet files (this does not extract files from merge modules).
             {
-                ExtractEmbeddedFilesCommand extractEmbeddedFilesCommand = new ExtractEmbeddedFilesCommand();
-                extractEmbeddedFilesCommand.FilesWithEmbeddedFiles = filesWithEmbeddedFiles;
+                var extractEmbeddedFilesCommand = new ExtractEmbeddedFilesCommand();
+                extractEmbeddedFilesCommand.FilesWithEmbeddedFiles = ExpectedEmbeddedFiles;
                 extractEmbeddedFilesCommand.Execute();
             }
 
@@ -198,10 +235,10 @@ namespace WixToolset.Bind
 
                     case WixBundlePackageType.Msi:
                         {
-                            ProcessMsiPackageCommand command = new ProcessMsiPackageCommand();
+                            var command = new ProcessMsiPackageCommand();
                             command.AuthoredPayloads = payloads;
                             command.Facade = facade;
-                            command.FileManager = this.FileManagers.First();
+                            command.BackendExtensions = this.BackendExtensions;
                             command.MsiFeatureTable = this.Output.EnsureTable(this.TableDefinitions["WixBundleMsiFeature"]);
                             command.MsiPropertyTable = this.Output.EnsureTable(this.TableDefinitions["WixBundleMsiProperty"]);
                             command.PayloadTable = this.Output.Tables["WixBundlePayload"];
@@ -377,11 +414,11 @@ namespace WixToolset.Bind
             }
 
             // Resolve any delayed fields before generating the manifest.
-            if (delayedFields.Any())
+            if (this.DelayedFields.Any())
             {
-                ResolveDelayedFieldsCommand resolveDelayedFieldsCommand = new ResolveDelayedFieldsCommand();
+                var resolveDelayedFieldsCommand = new ResolveDelayedFieldsCommand();
                 resolveDelayedFieldsCommand.OutputType = this.Output.Type;
-                resolveDelayedFieldsCommand.DelayedFields = delayedFields;
+                resolveDelayedFieldsCommand.DelayedFields = this.DelayedFields;
                 resolveDelayedFieldsCommand.ModularizationGuid = null;
                 resolveDelayedFieldsCommand.VariableCache = variableCache;
                 resolveDelayedFieldsCommand.Execute();
@@ -406,17 +443,17 @@ namespace WixToolset.Bind
                 command.Output = this.Output;
                 command.Payloads = payloads;
                 command.TableDefinitions = this.TableDefinitions;
-                command.TempFilesLocation = this.TempFilesLocation;
+                command.TempFilesLocation = this.IntermediateFolder;
                 command.Execute();
 
                 WixBundlePayloadRow baManifestPayload = command.BootstrapperApplicationManifestPayloadRow;
                 payloads.Add(baManifestPayload);
             }
 
-            foreach (BinderExtension extension in this.Extensions)
-            {
-                extension.Finish(Output);
-            }
+            //foreach (BinderExtension extension in this.Extensions)
+            //{
+            //    extension.PostBind(this.Context);
+            //}
 
             // Create all the containers except the UX container first so the manifest (that goes in the UX container)
             // can contain all size and hash information about the non-UX containers.
@@ -441,7 +478,7 @@ namespace WixToolset.Bind
                 }
                 else if (Compiler.BurnUXContainerId == container.Id)
                 {
-                    container.WorkingPath = Path.Combine(this.TempFilesLocation, container.Name);
+                    container.WorkingPath = Path.Combine(this.IntermediateFolder, container.Name);
                     container.AttachedContainerIndex = 0;
 
                     // Gather the list of UX payloads but ensure the BootstrapperApplication Payload is the first
@@ -466,7 +503,7 @@ namespace WixToolset.Bind
                 }
                 else
                 {
-                    container.WorkingPath = Path.Combine(this.TempFilesLocation, container.Name);
+                    container.WorkingPath = Path.Combine(this.IntermediateFolder, container.Name);
 
                     // Add detached containers to the list of file transfers.
                     if (ContainerType.Detached == container.Type)
@@ -491,10 +528,10 @@ namespace WixToolset.Bind
             }
 
             // Create the bundle manifest then UX container.
-            string manifestPath = Path.Combine(this.TempFilesLocation, "bundle-manifest.xml");
+            string manifestPath = Path.Combine(this.IntermediateFolder, "bundle-manifest.xml");
             {
-                CreateBurnManifestCommand command = new CreateBurnManifestCommand();
-                command.FileManagers = this.FileManagers;
+                var command = new CreateBurnManifestCommand();
+                command.BackendExtensions = this.BackendExtensions;
                 command.Output = this.Output;
 
                 command.BundleInfo = bundleRow;
@@ -519,7 +556,7 @@ namespace WixToolset.Bind
             string stubPlatform = (Platform.X64 == bundleRow.Platform) ? "x86" : bundleRow.Platform.ToString();
 
             string stubFile = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), stubPlatform, "burn.exe");
-            string bundleTempPath = Path.Combine(this.TempFilesLocation, Path.GetFileName(this.OutputPath));
+            string bundleTempPath = Path.Combine(this.IntermediateFolder, Path.GetFileName(this.OutputPath));
 
             Messaging.Instance.OnMessage(WixVerboses.GeneratingBundle(bundleTempPath, stubFile));
 
diff --git a/src/WixToolset.Core/ProvidesDependency.cs b/src/WixToolset.Core.Burn/Bind/ProvidesDependency.cs
index ea96b5c8..e64773b4 100644
--- a/src/WixToolset.Core/ProvidesDependency.cs
+++ b/src/WixToolset.Core.Burn/Bind/ProvidesDependency.cs
@@ -1,6 +1,6 @@
 // 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
+namespace WixToolset.Core.Burn
 {
     using System;
     using System.Xml;
diff --git a/src/WixToolset.Core/ProvidesDependencyCollection.cs b/src/WixToolset.Core.Burn/Bind/ProvidesDependencyCollection.cs
index a777afb0..668b81d3 100644
--- a/src/WixToolset.Core/ProvidesDependencyCollection.cs
+++ b/src/WixToolset.Core.Burn/Bind/ProvidesDependencyCollection.cs
@@ -1,6 +1,6 @@
 // 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
+namespace WixToolset.Core.Burn
 {
     using System;
     using System.Collections.ObjectModel;
diff --git a/src/WixToolset.Core/WixComponentSearchInfo.cs b/src/WixToolset.Core.Burn/Bind/WixComponentSearchInfo.cs
index dfd5d8ba..f605d7c7 100644
--- a/src/WixToolset.Core/WixComponentSearchInfo.cs
+++ b/src/WixToolset.Core.Burn/Bind/WixComponentSearchInfo.cs
@@ -1,6 +1,6 @@
 // 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
+namespace WixToolset.Core.Burn
 {
     using System;
     using System.Xml;
diff --git a/src/WixToolset.Core/WixFileSearchInfo.cs b/src/WixToolset.Core.Burn/Bind/WixFileSearchInfo.cs
index e53f7bf7..ea955db4 100644
--- a/src/WixToolset.Core/WixFileSearchInfo.cs
+++ b/src/WixToolset.Core.Burn/Bind/WixFileSearchInfo.cs
@@ -1,6 +1,6 @@
 // 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
+namespace WixToolset.Core.Burn
 {
     using System;
     using System.Xml;
diff --git a/src/WixToolset.Core/WixProductSearchInfo.cs b/src/WixToolset.Core.Burn/Bind/WixProductSearchInfo.cs
index 4c57d8be..b3bf5fee 100644
--- a/src/WixToolset.Core/WixProductSearchInfo.cs
+++ b/src/WixToolset.Core.Burn/Bind/WixProductSearchInfo.cs
@@ -1,6 +1,6 @@
 // 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
+namespace WixToolset.Core.Burn
 {
     using System;
     using System.Xml;
diff --git a/src/WixToolset.Core/WixRegistrySearchInfo.cs b/src/WixToolset.Core.Burn/Bind/WixRegistrySearchInfo.cs
index e8d7ce9b..e25f25f4 100644
--- a/src/WixToolset.Core/WixRegistrySearchInfo.cs
+++ b/src/WixToolset.Core.Burn/Bind/WixRegistrySearchInfo.cs
@@ -1,6 +1,6 @@
 // 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
+namespace WixToolset.Core.Burn
 {
     using System;
     using System.Xml;
diff --git a/src/WixToolset.Core/WixSearchInfo.cs b/src/WixToolset.Core.Burn/Bind/WixSearchInfo.cs
index 906365a2..9ebca4ae 100644
--- a/src/WixToolset.Core/WixSearchInfo.cs
+++ b/src/WixToolset.Core.Burn/Bind/WixSearchInfo.cs
@@ -1,6 +1,6 @@
 // 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
+namespace WixToolset.Core.Burn
 {
     using System;
     using System.Diagnostics;
diff --git a/src/WixToolset.Core.Burn/BundleBackend.cs b/src/WixToolset.Core.Burn/BundleBackend.cs
new file mode 100644
index 00000000..ef4d362c
--- /dev/null
+++ b/src/WixToolset.Core.Burn/BundleBackend.cs
@@ -0,0 +1,58 @@
+// 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.Burn
+{
+    using System;
+    using System.IO;
+    using WixToolset.Core.Burn.Bundles;
+    using WixToolset.Core.Burn.Inscribe;
+    using WixToolset.Data;
+    using WixToolset.Data.Bind;
+    using WixToolset.Extensibility;
+
+    internal class BundleBackend : IBackend
+    {
+        public BindResult Bind(IBindContext context)
+        {
+            BindBundleCommand command = new BindBundleCommand(context);
+            //command.DefaultCompressionLevel = context.DefaultCompressionLevel;
+            //command.Extensions = context.Extensions;
+            //command.IntermediateFolder = context.IntermediateFolder;
+            //command.Output = context.IntermediateRepresentation;
+            //command.OutputPath = context.OutputPath;
+            //command.PdbFile = context.OutputPdbPath;
+            //command.WixVariableResolver = context.WixVariableResolver;
+            command.Execute();
+
+            return new BindResult(command.FileTransfers, command.ContentFilePaths);
+        }
+
+        public bool Inscribe(IInscribeContext context)
+        {
+            if (String.IsNullOrEmpty(context.SignedEngineFile))
+            {
+                var command = new InscribeBundleCommand(context);
+                return command.Execute();
+            }
+            else
+            {
+                var command = new InscribeBundleEngineCommand(context);
+                return command.Execute();
+            }
+        }
+
+        public Output Unbind(IUnbindContext context)
+        {
+            string uxExtractPath = Path.Combine(context.ExportBasePath, "UX");
+            string acExtractPath = Path.Combine(context.ExportBasePath, "AttachedContainer");
+
+            using (BurnReader reader = BurnReader.Open(context.InputFilePath))
+            {
+                reader.ExtractUXContainer(uxExtractPath, context.IntermediateFolder);
+                reader.ExtractAttachedContainer(acExtractPath, context.IntermediateFolder);
+            }
+
+            return null;
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Bind/Bundles/AutomaticallySlipstreamPatchesCommand.cs b/src/WixToolset.Core.Burn/Bundles/AutomaticallySlipstreamPatchesCommand.cs
index eb02a983..bac8633b 100644
--- a/src/WixToolset.Core/Bind/Bundles/AutomaticallySlipstreamPatchesCommand.cs
+++ b/src/WixToolset.Core.Burn/Bundles/AutomaticallySlipstreamPatchesCommand.cs
@@ -1,6 +1,6 @@
 // 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.Bind.Bundles
+namespace WixToolset.Core.Burn.Bundles
 {
     using System;
     using System.Collections.Generic;
@@ -9,7 +9,7 @@ namespace WixToolset.Bind.Bundles
     using WixToolset.Data;
     using WixToolset.Data.Rows;
 
-    internal class AutomaticallySlipstreamPatchesCommand : ICommand
+    internal class AutomaticallySlipstreamPatchesCommand
     {
         public IEnumerable<PackageFacade> PackageFacades { private get; set; }
 
diff --git a/src/WixToolset.Core/Bind/Bundles/BurnCommon.cs b/src/WixToolset.Core.Burn/Bundles/BurnCommon.cs
index 8cb07791..0baa6094 100644
--- a/src/WixToolset.Core/Bind/Bundles/BurnCommon.cs
+++ b/src/WixToolset.Core.Burn/Bundles/BurnCommon.cs
@@ -1,6 +1,6 @@
 // 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.Bind.Bundles
+namespace WixToolset.Core.Burn.Bundles
 {
     using System;
     using System.Diagnostics;
diff --git a/src/WixToolset.Core/Bind/Bundles/BurnReader.cs b/src/WixToolset.Core.Burn/Bundles/BurnReader.cs
index f6d7a197..261ef7b4 100644
--- a/src/WixToolset.Core/Bind/Bundles/BurnReader.cs
+++ b/src/WixToolset.Core.Burn/Bundles/BurnReader.cs
@@ -1,13 +1,13 @@
 // 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.Bind.Bundles
+namespace WixToolset.Core.Burn.Bundles
 {
     using System;
     using System.Collections;
     using System.Collections.Generic;
     using System.IO;
     using System.Xml;
-    using WixToolset.Cab;
+    using WixToolset.Core.Cab;
 
     /// <summary>
     /// Burn PE reader for the WiX toolset.
@@ -49,6 +49,11 @@ namespace WixToolset.Bind.Bundles
             }
         }
 
+        internal static BurnReader Open(object inputFilePath)
+        {
+            throw new NotImplementedException();
+        }
+
         /// <summary>
         /// Opens a Burn reader.
         /// </summary>
@@ -96,7 +101,7 @@ namespace WixToolset.Bind.Bundles
                 BurnCommon.CopyStream(this.binaryReader.BaseStream, tempCab, (int)this.UXSize);
             }
 
-            using (WixExtractCab extract = new WixExtractCab())
+            using (var extract = new WixExtractCab())
             {
                 extract.Extract(tempCabPath, outputDirectory);
             }
@@ -144,6 +149,11 @@ namespace WixToolset.Bind.Bundles
             return true;
         }
 
+        internal void ExtractUXContainer(string uxExtractPath, object intermediateFolder)
+        {
+            throw new NotImplementedException();
+        }
+
         /// <summary>
         /// Gets the attached container from the exe and extracts its contents to the output directory.
         /// </summary>
diff --git a/src/WixToolset.Core/Bind/Bundles/BurnWriter.cs b/src/WixToolset.Core.Burn/Bundles/BurnWriter.cs
index bc0baf46..e7365212 100644
--- a/src/WixToolset.Core/Bind/Bundles/BurnWriter.cs
+++ b/src/WixToolset.Core.Burn/Bundles/BurnWriter.cs
@@ -1,6 +1,6 @@
 // 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.Bind.Bundles
+namespace WixToolset.Core.Burn.Bundles
 {
     using System;
     using System.Diagnostics;
diff --git a/src/WixToolset.Core/Bind/Bundles/CreateBootstrapperApplicationManifestCommand.cs b/src/WixToolset.Core.Burn/Bundles/CreateBootstrapperApplicationManifestCommand.cs
index 1040b394..58814efc 100644
--- a/src/WixToolset.Core/Bind/Bundles/CreateBootstrapperApplicationManifestCommand.cs
+++ b/src/WixToolset.Core.Burn/Bundles/CreateBootstrapperApplicationManifestCommand.cs
@@ -1,6 +1,6 @@
 // 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.Bind.Bundles
+namespace WixToolset.Core.Burn.Bundles
 {
     using System;
     using System.Collections.Generic;
@@ -12,7 +12,7 @@ namespace WixToolset.Bind.Bundles
     using WixToolset.Data;
     using WixToolset.Data.Rows;
 
-    internal class CreateBootstrapperApplicationManifestCommand : ICommand
+    internal class CreateBootstrapperApplicationManifestCommand
     {
         public WixBundleRow BundleRow { private get; set; }
 
diff --git a/src/WixToolset.Core/Bind/Bundles/CreateBurnManifestCommand.cs b/src/WixToolset.Core.Burn/Bundles/CreateBurnManifestCommand.cs
index 7bc708a3..772265a0 100644
--- a/src/WixToolset.Core/Bind/Bundles/CreateBurnManifestCommand.cs
+++ b/src/WixToolset.Core.Burn/Bundles/CreateBurnManifestCommand.cs
@@ -1,6 +1,6 @@
 // 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.Bind.Bundles
+namespace WixToolset.Core.Burn.Bundles
 {
     using System;
     using System.Collections.Generic;
@@ -13,9 +13,9 @@ namespace WixToolset.Bind.Bundles
     using WixToolset.Data.Rows;
     using WixToolset.Extensibility;
 
-    internal class CreateBurnManifestCommand : ICommand
+    internal class CreateBurnManifestCommand
     {
-        public IEnumerable<IBinderFileManager> FileManagers { private get; set; }
+        public IEnumerable<IBurnBackendExtension> BackendExtensions { private get; set; }
 
         public Output Output { private get; set; }
 
@@ -671,9 +671,9 @@ namespace WixToolset.Bind.Bundles
         private string ResolveUrl(string url, string fallbackUrl, string packageId, string payloadId, string fileName)
         {
             string resolved = null;
-            foreach (IBinderFileManager fileManager in this.FileManagers)
+            foreach (var extension in this.BackendExtensions)
             {
-                resolved = fileManager.ResolveUrl(url, fallbackUrl, packageId, payloadId, fileName);
+                resolved = extension.ResolveUrl(url, fallbackUrl, packageId, payloadId, fileName);
                 if (!String.IsNullOrEmpty(resolved))
                 {
                     break;
diff --git a/src/WixToolset.Core/Bind/Bundles/CreateContainerCommand.cs b/src/WixToolset.Core.Burn/Bundles/CreateContainerCommand.cs
index 1bf987e3..75379713 100644
--- a/src/WixToolset.Core/Bind/Bundles/CreateContainerCommand.cs
+++ b/src/WixToolset.Core.Burn/Bundles/CreateContainerCommand.cs
@@ -1,20 +1,20 @@
 // 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.Bind.Bundles
+namespace WixToolset.Core.Burn.Bundles
 {
     using System;
     using System.Collections.Generic;
     using System.Diagnostics;
     using System.IO;
     using System.Linq;
-    using WixToolset.Cab;
+    using WixToolset.Core.Cab;
     using WixToolset.Data;
     using WixToolset.Data.Rows;
 
     /// <summary>
     /// Creates cabinet files.
     /// </summary>
-    internal class CreateContainerCommand : ICommand
+    internal class CreateContainerCommand
     {
         public CompressionLevel DefaultCompressionLevel { private get; set; }
 
@@ -37,7 +37,7 @@ namespace WixToolset.Bind.Bundles
                 ++payloadCount;
             }
 
-            using (WixCreateCab cab = new WixCreateCab(Path.GetFileName(this.OutputPath), Path.GetDirectoryName(this.OutputPath), payloadCount, 0, 0, this.DefaultCompressionLevel))
+            using (var cab = new WixCreateCab(Path.GetFileName(this.OutputPath), Path.GetDirectoryName(this.OutputPath), payloadCount, 0, 0, this.DefaultCompressionLevel))
             {
                 // If a manifest was provided always add it as "payload 0" to the container.
                 if (!String.IsNullOrEmpty(this.ManifestFile))
diff --git a/src/WixToolset.Core/Bind/Bundles/GetPackageFacadesCommand.cs b/src/WixToolset.Core.Burn/Bundles/GetPackageFacadesCommand.cs
index dc19e380..7485758c 100644
--- a/src/WixToolset.Core/Bind/Bundles/GetPackageFacadesCommand.cs
+++ b/src/WixToolset.Core.Burn/Bundles/GetPackageFacadesCommand.cs
@@ -1,12 +1,12 @@
 // 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.Bind.Bundles
+namespace WixToolset.Core.Burn.Bundles
 {
     using System.Collections.Generic;
     using WixToolset.Data;
     using WixToolset.Data.Rows;
 
-    internal class GetPackageFacadesCommand : ICommand
+    internal class GetPackageFacadesCommand
     {
         public Table PackageTable { private get; set; }
 
diff --git a/src/WixToolset.Core/Bind/Bundles/OrderPackagesAndRollbackBoundariesCommand.cs b/src/WixToolset.Core.Burn/Bundles/OrderPackagesAndRollbackBoundariesCommand.cs
index ac3a301d..cb6e2748 100644
--- a/src/WixToolset.Core/Bind/Bundles/OrderPackagesAndRollbackBoundariesCommand.cs
+++ b/src/WixToolset.Core.Burn/Bundles/OrderPackagesAndRollbackBoundariesCommand.cs
@@ -1,13 +1,13 @@
 // 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.Bind.Bundles
+namespace WixToolset.Core.Burn.Bundles
 {
     using System;
     using System.Collections.Generic;
     using WixToolset.Data;
     using WixToolset.Data.Rows;
 
-    internal class OrderPackagesAndRollbackBoundariesCommand : ICommand
+    internal class OrderPackagesAndRollbackBoundariesCommand
     {
         public Table WixGroupTable { private get; set; }
 
diff --git a/src/WixToolset.Core/Bind/Bundles/PackageFacade.cs b/src/WixToolset.Core.Burn/Bundles/PackageFacade.cs
index f7e6410f..3f2e184d 100644
--- a/src/WixToolset.Core/Bind/Bundles/PackageFacade.cs
+++ b/src/WixToolset.Core.Burn/Bundles/PackageFacade.cs
@@ -1,6 +1,6 @@
 // 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.Bind.Bundles
+namespace WixToolset.Core.Burn.Bundles
 {
     using WixToolset.Data.Rows;
 
diff --git a/src/WixToolset.Core/Bind/Bundles/ProcessExePackageCommand.cs b/src/WixToolset.Core.Burn/Bundles/ProcessExePackageCommand.cs
index a1e7c271..11512c39 100644
--- a/src/WixToolset.Core/Bind/Bundles/ProcessExePackageCommand.cs
+++ b/src/WixToolset.Core.Burn/Bundles/ProcessExePackageCommand.cs
@@ -1,6 +1,6 @@
 // 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.Bind.Bundles
+namespace WixToolset.Core.Burn.Bundles
 {
     using System;
     using WixToolset.Data;
@@ -9,7 +9,7 @@ namespace WixToolset.Bind.Bundles
     /// <summary>
     /// Initializes package state from the Exe contents.
     /// </summary>
-    internal class ProcessExePackageCommand : ICommand
+    internal class ProcessExePackageCommand
     {
         public RowDictionary<WixBundlePayloadRow> AuthoredPayloads { private get; set; }
 
diff --git a/src/WixToolset.Core/Bind/Bundles/ProcessMsiPackageCommand.cs b/src/WixToolset.Core.Burn/Bundles/ProcessMsiPackageCommand.cs
index f73776c0..322187f9 100644
--- a/src/WixToolset.Core/Bind/Bundles/ProcessMsiPackageCommand.cs
+++ b/src/WixToolset.Core.Burn/Bundles/ProcessMsiPackageCommand.cs
@@ -1,6 +1,6 @@
 // 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.Bind.Bundles
+namespace WixToolset.Core.Burn.Bundles
 {
     using System;
     using System.Collections;
@@ -12,14 +12,15 @@ namespace WixToolset.Bind.Bundles
     using WixToolset.Data;
     using WixToolset.Data.Rows;
     using WixToolset.Extensibility;
-    using WixToolset.Msi;
     using WixToolset.Core.Native;
     using Dtf = WixToolset.Dtf.WindowsInstaller;
+    using WixToolset.Bind;
+    using WixToolset.Data.Bind;
 
     /// <summary>
     /// Initializes package state from the MSI contents.
     /// </summary>
-    internal class ProcessMsiPackageCommand : ICommand
+    internal class ProcessMsiPackageCommand
     {
         private const string PropertySqlFormat = "SELECT `Value` FROM `Property` WHERE `Property` = '{0}'";
 
@@ -27,7 +28,7 @@ namespace WixToolset.Bind.Bundles
 
         public PackageFacade Facade { private get; set; }
 
-        public IBinderFileManager FileManager { private get; set; }
+        public IEnumerable<IBurnBackendExtension> BackendExtensions { private get; set; }
 
         public Table MsiFeatureTable { private get; set; }
 
@@ -365,7 +366,7 @@ namespace WixToolset.Bind.Bundles
                         if (!payloadNames.Contains(cabinetName))
                         {
                             string generatedId = Common.GenerateIdentifier("cab", packagePayload.Id, cabinet);
-                            string payloadSourceFile = FileManager.ResolveRelatedFile(packagePayload.UnresolvedSourceFile, cabinet, "Cabinet", this.Facade.Package.SourceLineNumbers, BindStage.Normal);
+                            string payloadSourceFile = this.ResolveRelatedFile(packagePayload.UnresolvedSourceFile, cabinet, "Cabinet", this.Facade.Package.SourceLineNumbers, BindStage.Normal);
 
                             WixBundlePayloadRow payload = (WixBundlePayloadRow)this.PayloadTable.CreateRow(this.Facade.Package.SourceLineNumbers);
                             payload.Id = generatedId;
@@ -407,7 +408,7 @@ namespace WixToolset.Bind.Bundles
                                 break;
                             }
 
-                            string sourceName = Installer.GetName(record.GetString(3), true, longNamesInImage);
+                            string sourceName = Common.GetName(record.GetString(3), true, longNamesInImage);
                             directories.Add(record.GetString(1), new ResolvedDirectory(record.GetString(2), sourceName));
                         }
                     }
@@ -441,7 +442,7 @@ namespace WixToolset.Bind.Bundles
                                     if (!payloadNames.Contains(name))
                                     {
                                         string generatedId = Common.GenerateIdentifier("f", packagePayload.Id, record.GetString(2));
-                                        string payloadSourceFile = FileManager.ResolveRelatedFile(packagePayload.UnresolvedSourceFile, fileSourcePath, "File", this.Facade.Package.SourceLineNumbers, BindStage.Normal);
+                                        string payloadSourceFile = this.ResolveRelatedFile(packagePayload.UnresolvedSourceFile, fileSourcePath, "File", this.Facade.Package.SourceLineNumbers, BindStage.Normal);
 
                                         WixBundlePayloadRow payload = (WixBundlePayloadRow)this.PayloadTable.CreateRow(this.Facade.Package.SourceLineNumbers);
                                         payload.Id = generatedId;
@@ -510,6 +511,21 @@ namespace WixToolset.Bind.Bundles
             }
         }
 
+        private string ResolveRelatedFile(string sourceFile, string relatedSource, string type, SourceLineNumber sourceLineNumbers, BindStage stage)
+        {
+            foreach (var extension in this.BackendExtensions)
+            {
+                var relatedFile = extension.ResolveRelatedFile(sourceFile, relatedSource, type, sourceLineNumbers, stage);
+
+                if (!String.IsNullOrEmpty(relatedFile))
+                {
+                    return relatedFile;
+                }
+            }
+
+            return null;
+        }
+
         /// <summary>
         /// Queries a Windows Installer database for a Property value.
         /// </summary>
diff --git a/src/WixToolset.Core/Bind/Bundles/ProcessMspPackageCommand.cs b/src/WixToolset.Core.Burn/Bundles/ProcessMspPackageCommand.cs
index 24063221..2d849d03 100644
--- a/src/WixToolset.Core/Bind/Bundles/ProcessMspPackageCommand.cs
+++ b/src/WixToolset.Core.Burn/Bundles/ProcessMspPackageCommand.cs
@@ -1,6 +1,6 @@
 // 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.Bind.Bundles
+namespace WixToolset.Core.Burn.Bundles
 {
     using System;
     using System.Collections.Generic;
@@ -16,7 +16,7 @@ namespace WixToolset.Bind.Bundles
     /// <summary>
     /// Initializes package state from the Msp contents.
     /// </summary>
-    internal class ProcessMspPackageCommand : ICommand
+    internal class ProcessMspPackageCommand
     {
         private const string PatchMetadataFormat = "SELECT `Value` FROM `MsiPatchMetadata` WHERE `Property` = '{0}'";
         private static readonly Encoding XmlOutputEncoding = new UTF8Encoding(false);
diff --git a/src/WixToolset.Core/Bind/Bundles/ProcessMsuPackageCommand.cs b/src/WixToolset.Core.Burn/Bundles/ProcessMsuPackageCommand.cs
index ba59f5f5..fcfc780c 100644
--- a/src/WixToolset.Core/Bind/Bundles/ProcessMsuPackageCommand.cs
+++ b/src/WixToolset.Core.Burn/Bundles/ProcessMsuPackageCommand.cs
@@ -1,6 +1,6 @@
 // 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.Bind.Bundles
+namespace WixToolset.Core.Burn.Bundles
 {
     using System;
     using WixToolset.Data;
@@ -9,7 +9,7 @@ namespace WixToolset.Bind.Bundles
     /// <summary>
     /// Processes the Msu packages to add properties and payloads from the Msu packages.
     /// </summary>
-    internal class ProcessMsuPackageCommand : ICommand
+    internal class ProcessMsuPackageCommand
     {
         public RowDictionary<WixBundlePayloadRow> AuthoredPayloads { private get; set; }
 
diff --git a/src/WixToolset.Core/Bind/Bundles/ProcessPayloadsCommand.cs b/src/WixToolset.Core.Burn/Bundles/ProcessPayloadsCommand.cs
index a83a7a4a..5dbd6aaa 100644
--- a/src/WixToolset.Core/Bind/Bundles/ProcessPayloadsCommand.cs
+++ b/src/WixToolset.Core.Burn/Bundles/ProcessPayloadsCommand.cs
@@ -1,6 +1,6 @@
 // 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.Bind.Bundles
+namespace WixToolset.Core.Burn.Bundles
 {
     using System;
     using System.Collections.Generic;
@@ -9,10 +9,12 @@ namespace WixToolset.Bind.Bundles
     using System.Security.Cryptography;
     using System.Security.Cryptography.X509Certificates;
     using System.Text;
+    using WixToolset.Bind;
     using WixToolset.Data;
+    using WixToolset.Data.Bind;
     using WixToolset.Data.Rows;
 
-    internal class ProcessPayloadsCommand : ICommand
+    internal class ProcessPayloadsCommand
     {
         private static readonly Version EmptyVersion = new Version(0, 0, 0, 0);
 
diff --git a/src/WixToolset.Core/Bind/Bundles/VerifyPayloadsWithCatalogCommand.cs b/src/WixToolset.Core.Burn/Bundles/VerifyPayloadsWithCatalogCommand.cs
index 9c614c26..9919f777 100644
--- a/src/WixToolset.Core/Bind/Bundles/VerifyPayloadsWithCatalogCommand.cs
+++ b/src/WixToolset.Core.Burn/Bundles/VerifyPayloadsWithCatalogCommand.cs
@@ -1,6 +1,6 @@
 // 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.Bind.Bundles
+namespace WixToolset.Core.Burn.Bundles
 {
     using System;
     using System.Collections.Generic;
@@ -11,7 +11,7 @@ namespace WixToolset.Bind.Bundles
     using WixToolset.Data;
     using WixToolset.Data.Rows;
 
-    internal class VerifyPayloadsWithCatalogCommand : ICommand
+    internal class VerifyPayloadsWithCatalogCommand
     {
         public IEnumerable<WixBundleCatalogRow> Catalogs { private get; set; }
 
diff --git a/src/WixToolset.Core.Burn/Inscribe/InscribeBundleCommand.cs b/src/WixToolset.Core.Burn/Inscribe/InscribeBundleCommand.cs
new file mode 100644
index 00000000..5eb76479
--- /dev/null
+++ b/src/WixToolset.Core.Burn/Inscribe/InscribeBundleCommand.cs
@@ -0,0 +1,53 @@
+// 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.Burn.Inscribe
+{
+    using System.IO;
+    using WixToolset.Core.Burn.Bundles;
+    using WixToolset.Extensibility;
+
+    internal class InscribeBundleCommand
+    {
+        public InscribeBundleCommand(IInscribeContext context)
+        {
+            this.Context = context;
+        }
+
+        private IInscribeContext Context { get; }
+
+        public bool Execute()
+        {
+            bool inscribed = false;
+            string tempFile = Path.Combine(this.Context.IntermediateFolder, "bundle_engine_signed.exe");
+
+            using (BurnReader reader = BurnReader.Open(this.Context.InputFilePath))
+            {
+                File.Copy(this.Context.SignedEngineFile, tempFile, true);
+
+                // If there was an attached container on the original (unsigned) bundle, put it back.
+                if (reader.AttachedContainerSize > 0)
+                {
+                    reader.Stream.Seek(reader.AttachedContainerAddress, SeekOrigin.Begin);
+
+                    using (BurnWriter writer = BurnWriter.Open(tempFile))
+                    {
+                        writer.RememberThenResetSignature();
+                        writer.AppendContainer(reader.Stream, reader.AttachedContainerSize, BurnCommon.Container.Attached);
+                        inscribed = true;
+                    }
+                }
+            }
+
+            Directory.CreateDirectory(Path.GetDirectoryName(this.Context.OutputFile));
+            if (File.Exists(this.Context.OutputFile))
+            {
+                File.Delete(this.Context.OutputFile);
+            }
+
+            File.Move(tempFile, this.Context.OutputFile);
+            WixToolset.Core.Native.NativeMethods.ResetAcls(new string[] { this.Context.OutputFile }, 1);
+
+            return inscribed;
+        }
+    }
+}
diff --git a/src/WixToolset.Core.Burn/Inscribe/InscribeBundleEngineCommand.cs b/src/WixToolset.Core.Burn/Inscribe/InscribeBundleEngineCommand.cs
new file mode 100644
index 00000000..26af056b
--- /dev/null
+++ b/src/WixToolset.Core.Burn/Inscribe/InscribeBundleEngineCommand.cs
@@ -0,0 +1,61 @@
+// 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.Burn.Inscribe
+{
+    using System;
+    using System.IO;
+    using WixToolset.Core.Burn.Bundles;
+    using WixToolset.Extensibility;
+
+    internal class InscribeBundleEngineCommand
+    {
+        public InscribeBundleEngineCommand(IInscribeContext context)
+        {
+            this.Context = context;
+        }
+
+        private IInscribeContext Context { get; }
+
+        public bool Execute()
+        {
+            string tempFile = Path.Combine(this.Context.IntermediateFolder, "bundle_engine_unsigned.exe");
+
+            using (BurnReader reader = BurnReader.Open(this.Context.InputFilePath))
+            using (FileStream writer = File.Open(tempFile, FileMode.Create, FileAccess.Write, FileShare.Read | FileShare.Delete))
+            {
+                reader.Stream.Seek(0, SeekOrigin.Begin);
+
+                byte[] buffer = new byte[4 * 1024];
+                int total = 0;
+                int read = 0;
+                do
+                {
+                    read = Math.Min(buffer.Length, (int)reader.EngineSize - total);
+
+                    read = reader.Stream.Read(buffer, 0, read);
+                    writer.Write(buffer, 0, read);
+
+                    total += read;
+                } while (total < reader.EngineSize && 0 < read);
+
+                if (total != reader.EngineSize)
+                {
+                    throw new InvalidOperationException("Failed to copy engine out of bundle.");
+                }
+
+                // TODO: update writer with detached container signatures.
+            }
+
+            Directory.CreateDirectory(Path.GetDirectoryName(this.Context.OutputFile));
+            if (File.Exists(this.Context.OutputFile))
+            {
+                File.Delete(this.Context.OutputFile);
+            }
+
+            File.Move(tempFile, this.Context.OutputFile);
+            WixToolset.Core.Native.NativeMethods.ResetAcls(new string[] { this.Context.OutputFile }, 1);
+
+            return true;
+        }
+    }
+}
diff --git a/src/WixToolset.Core/VerifyInterop.cs b/src/WixToolset.Core.Burn/VerifyInterop.cs
index 81fbec65..81fbec65 100644
--- a/src/WixToolset.Core/VerifyInterop.cs
+++ b/src/WixToolset.Core.Burn/VerifyInterop.cs
diff --git a/src/WixToolset.Core.Burn/WixToolset.Core.Burn.csproj b/src/WixToolset.Core.Burn/WixToolset.Core.Burn.csproj
new file mode 100644
index 00000000..878ac200
--- /dev/null
+++ b/src/WixToolset.Core.Burn/WixToolset.Core.Burn.csproj
@@ -0,0 +1,36 @@
+<?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">
+  <PropertyGroup>
+    <TargetFramework>netstandard2.0</TargetFramework>
+    <Description>Core Burn</Description>
+    <Title>WiX Toolset Core Burn</Title>
+  </PropertyGroup>
+
+  <PropertyGroup>
+    <NoWarn>NU1701</NoWarn>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="$(WixToolsetRootFolder)\Data\src\WixToolset.Data\WixToolset.Data.csproj" Condition=" '$(Configuration)' == 'Debug' And Exists('$(WixToolsetRootFolder)\Data\src\WixToolset.Data\WixToolset.Data.csproj') " />
+    <PackageReference Include="WixToolset.Data" Version="4.0.*" Condition=" '$(Configuration)' == 'Release' Or !Exists('$(WixToolsetRootFolder)\Data\src\WixToolset.Data\WixToolset.Data.csproj') " />
+
+    <ProjectReference Include="$(WixToolsetRootFolder)\Extensibility\src\WixToolset.Extensibility\WixToolset.Extensibility.csproj" Condition=" '$(Configuration)' == 'Debug' And Exists('$(WixToolsetRootFolder)\Extensibility\src\WixToolset.Extensibility\WixToolset.Extensibility.csproj') " />
+    <PackageReference Include="WixToolset.Extensibility" Version="4.0.*" Condition=" '$(Configuration)' == 'Release' Or !Exists('$(WixToolsetRootFolder)\Extensibility\src\WixToolset.Extensibility\WixToolset.Extensibility.csproj') " />
+
+    <ProjectReference Include="$(WixToolsetRootFolder)\Core.Native\src\WixToolset.Core.Native\WixToolset.Core.Native.csproj" Condition=" '$(Configuration)' == 'Debug' And Exists('$(WixToolsetRootFolder)\Core.Native\src\WixToolset.Core.Native\WixToolset.Core.Native.csproj') " />
+
+    <ProjectReference Include="..\WixToolset.Core\WixToolset.Core.csproj" />
+    <PackageReference Include="WixToolset.Core.Native" Version="4.0.*" Condition=" '$(Configuration)' == 'Release' Or !Exists('$(WixToolsetRootFolder)\Core.Native\src\WixToolset.Core.Native\WixToolset.Core.Native.csproj') " />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="WixToolset.Dtf.Resources" Version="4.0.*" />
+    <PackageReference Include="WixToolset.Dtf.WindowsInstaller" Version="4.0.*" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Nerdbank.GitVersioning" Version="2.0.41" PrivateAssets="all" />
+  </ItemGroup>
+</Project>
diff --git a/src/WixToolset.Core/Bind/Databases/AssignMediaCommand.cs b/src/WixToolset.Core.WindowsInstaller/Bind/AssignMediaCommand.cs
index 5e2650e9..23c481b7 100644
--- a/src/WixToolset.Core/Bind/Databases/AssignMediaCommand.cs
+++ b/src/WixToolset.Core.WindowsInstaller/Bind/AssignMediaCommand.cs
@@ -1,18 +1,18 @@
 // 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.Bind.Databases
+namespace WixToolset.Core.WindowsInstaller.Databases
 {
     using System;
     using System.Collections.Generic;
     using System.Globalization;
-    using System.IO;
+    using WixToolset.Core.Bind;
     using WixToolset.Data;
     using WixToolset.Data.Rows;
 
     /// <summary>
     /// AssignMediaCommand assigns files to cabs based on Media or MediaTemplate rows.
     /// </summary>
-    public class AssignMediaCommand : ICommand
+    public class AssignMediaCommand
     {
         public AssignMediaCommand()
         {
diff --git a/src/WixToolset.Core/Bind/BindDatabaseCommand.cs b/src/WixToolset.Core.WindowsInstaller/Bind/BindDatabaseCommand.cs
index 93af2e9a..2e2c5417 100644
--- a/src/WixToolset.Core/Bind/BindDatabaseCommand.cs
+++ b/src/WixToolset.Core.WindowsInstaller/Bind/BindDatabaseCommand.cs
@@ -1,6 +1,6 @@
 // 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.Bind
+namespace WixToolset.Core.WindowsInstaller.Bind
 {
     using System;
     using System.Collections;
@@ -9,8 +9,11 @@ namespace WixToolset.Bind
     using System.Globalization;
     using System.IO;
     using System.Linq;
-    using WixToolset.Bind.Databases;
+    using WixToolset.Bind;
+    using WixToolset.Core.Bind;
+    using WixToolset.Core.WindowsInstaller.Databases;
     using WixToolset.Data;
+    using WixToolset.Data.Bind;
     using WixToolset.Data.Rows;
     using WixToolset.Extensibility;
     using WixToolset.Msi;
@@ -18,46 +21,72 @@ namespace WixToolset.Bind
     /// <summary>
     /// Binds a databse.
     /// </summary>
-    internal class BindDatabaseCommand : ICommand
+    internal class BindDatabaseCommand
     {
         // As outlined in RFC 4122, this is our namespace for generating name-based (version 3) UUIDs.
         private static readonly Guid WixComponentGuidNamespace = new Guid("{3064E5C6-FB63-4FE9-AC49-E446A792EFA5}");
 
-        public int Codepage { private get; set; }
+        public BindDatabaseCommand(IBindContext context, Validator validator)
+        {
+            this.TableDefinitions = WindowsInstallerStandard.GetTableDefinitions();
+
+            this.BindPaths = context.BindPaths;
+            this.CabbingThreadCount = context.CabbingThreadCount;
+            this.CabCachePath = context.CabCachePath;
+            this.Codepage = context.Codepage;
+            this.DefaultCompressionLevel = context.DefaultCompressionLevel;
+            this.DelayedFields = context.DelayedFields;
+            this.ExpectedEmbeddedFiles = context.ExpectedEmbeddedFiles;
+            this.Extensions = context.Extensions;
+            this.Output = context.IntermediateRepresentation;
+            this.OutputPath = context.OutputPath;
+            this.PdbFile = context.OutputPdbPath;
+            this.IntermediateFolder = context.IntermediateFolder;
+            this.Validator = validator;
+            this.WixVariableResolver = context.WixVariableResolver;
+
+            this.BackendExtensions = context.ExtensionManager.Create<IWindowsInstallerBackendExtension>();
+        }
 
-        public int CabbingThreadCount { private get; set; }
+        private IEnumerable<BindPath> BindPaths { get; }
 
-        public CompressionLevel DefaultCompressionLevel { private get; set; }
+        private int Codepage { get; }
 
-        public bool DeltaBinaryPatch { get; set; }
+        private int CabbingThreadCount { get; }
 
-        public IEnumerable<IBinderExtension> Extensions { private get; set; }
+        private string CabCachePath { get; }
 
-        public BinderFileManagerCore FileManagerCore { private get; set; }
+        private CompressionLevel DefaultCompressionLevel { get; }
 
-        public IEnumerable<IBinderFileManager> FileManagers { private get; set; }
+        public IEnumerable<IDelayedField> DelayedFields { get; }
 
-        public IEnumerable<InspectorExtension> InspectorExtensions { private get; set; }
+        public IEnumerable<IExpectedExtractFile> ExpectedEmbeddedFiles { get; }
+
+        public bool DeltaBinaryPatch { get; set; }
 
-        public Localizer Localizer { private get; set; }
+        private IEnumerable<IWindowsInstallerBackendExtension> BackendExtensions { get; }
 
-        public string PdbFile { private get; set; }
+        private IEnumerable<IBinderExtension> Extensions { get; }
 
-        public Output Output { private get; set; }
+        private IEnumerable<InspectorExtension> InspectorExtensions { get; }
 
-        public string OutputPath { private get; set; }
+        private string PdbFile { get; }
 
-        public bool SuppressAddingValidationRows { private get; set; }
+        private Output Output { get; }
 
-        public bool SuppressLayout { private get; set; }
+        private string OutputPath { get; }
 
-        public TableDefinitionCollection TableDefinitions { private get; set; }
+        private bool SuppressAddingValidationRows { get; }
 
-        public string TempFilesLocation { private get; set; }
+        private bool SuppressLayout { get; }
 
-        public Validator Validator { private get; set; }
+        private TableDefinitionCollection TableDefinitions { get; }
 
-        public WixVariableResolver WixVariableResolver { private get; set; }
+        private string IntermediateFolder { get; }
+
+        private Validator Validator { get; }
+
+        private IBindVariableResolver WixVariableResolver { get; }
 
         public IEnumerable<FileTransfer> FileTransfers { get; private set; }
 
@@ -69,43 +98,9 @@ namespace WixToolset.Bind
 
             HashSet<string> suppressedTableNames = new HashSet<string>();
 
-            // Localize fields, resolve wix variables, and resolve file paths.
-            ExtractEmbeddedFiles filesWithEmbeddedFiles = new ExtractEmbeddedFiles();
-
-            IEnumerable<DelayedField> delayedFields;
-            {
-                ResolveFieldsCommand command = new ResolveFieldsCommand();
-                command.Tables = this.Output.Tables;
-                command.FilesWithEmbeddedFiles = filesWithEmbeddedFiles;
-                command.FileManagerCore = this.FileManagerCore;
-                command.FileManagers = this.FileManagers;
-                command.SupportDelayedResolution = true;
-                command.TempFilesLocation = this.TempFilesLocation;
-                command.WixVariableResolver = this.WixVariableResolver;
-                command.Execute();
-
-                delayedFields = command.DelayedFields;
-            }
-
-            if (OutputType.Patch == this.Output.Type)
-            {
-                foreach (SubStorage transform in this.Output.SubStorages)
-                {
-                    ResolveFieldsCommand command = new ResolveFieldsCommand();
-                    command.Tables = transform.Data.Tables;
-                    command.FilesWithEmbeddedFiles = filesWithEmbeddedFiles;
-                    command.FileManagerCore = this.FileManagerCore;
-                    command.FileManagers = this.FileManagers;
-                    command.SupportDelayedResolution = false;
-                    command.TempFilesLocation = this.TempFilesLocation;
-                    command.WixVariableResolver = this.WixVariableResolver;
-                    command.Execute();
-                }
-            }
-
             // If there are any fields to resolve later, create the cache to populate during bind.
             IDictionary<string, string> variableCache = null;
-            if (delayedFields.Any())
+            if (this.DelayedFields.Any())
             {
                 variableCache = new Dictionary<string, string>(StringComparer.InvariantCultureIgnoreCase);
             }
@@ -231,7 +226,7 @@ namespace WixToolset.Bind
                     // Add the property name and value to the variableCache.
                     if (null != variableCache)
                     {
-                        string key = String.Concat("property.", Demodularize(this.Output.Type, modularizationGuid, propertyRow.Property));
+                        string key = String.Concat("property.", Common.Demodularize(this.Output.Type, modularizationGuid, propertyRow.Property));
                         variableCache[key] = propertyRow.Value;
                     }
                 }
@@ -240,7 +235,7 @@ namespace WixToolset.Bind
             // Extract files that come from cabinet files (this does not extract files from merge modules).
             {
                 ExtractEmbeddedFilesCommand command = new ExtractEmbeddedFilesCommand();
-                command.FilesWithEmbeddedFiles = filesWithEmbeddedFiles;
+                command.FilesWithEmbeddedFiles = this.ExpectedEmbeddedFiles;
                 command.Execute();
             }
 
@@ -258,7 +253,7 @@ namespace WixToolset.Bind
                     command.WixMergeTable = wixMergeTable;
                     command.OutputInstallerVersion = installerVersion;
                     command.SuppressLayout = this.SuppressLayout;
-                    command.TempFilesLocation = this.TempFilesLocation;
+                    command.TempFilesLocation = this.IntermediateFolder;
                     command.Execute();
 
                     fileFacades.AddRange(command.MergeModulesFileFacades);
@@ -303,11 +298,11 @@ namespace WixToolset.Bind
 
             this.UpdateControlText(this.Output);
 
-            if (delayedFields.Any())
+            if (this.DelayedFields.Any())
             {
                 ResolveDelayedFieldsCommand command = new ResolveDelayedFieldsCommand();
                 command.OutputType = this.Output.Type;
-                command.DelayedFields = delayedFields;
+                command.DelayedFields = this.DelayedFields;
                 command.ModularizationGuid = null;
                 command.VariableCache = variableCache;
                 command.Execute();
@@ -343,7 +338,7 @@ namespace WixToolset.Bind
             {
                 Table updatedFiles = this.Output.EnsureTable(this.TableDefinitions["WixBindUpdatedFiles"]);
 
-                foreach (BinderExtension extension in this.Extensions)
+                foreach (IBinderExtension extension in this.Extensions)
                 {
                     extension.AfterResolvedFields(this.Output);
                 }
@@ -379,14 +374,14 @@ namespace WixToolset.Bind
                 return;
             }
 
-            Directory.CreateDirectory(this.TempFilesLocation);
+            Directory.CreateDirectory(this.IntermediateFolder);
 
             if (OutputType.Patch == this.Output.Type && this.DeltaBinaryPatch)
             {
                 CreateDeltaPatchesCommand command = new CreateDeltaPatchesCommand();
                 command.FileFacades = fileFacades;
                 command.WixPatchIdTable = this.Output.Tables["WixPatchId"];
-                command.TempFilesLocation = this.TempFilesLocation;
+                command.TempFilesLocation = this.IntermediateFolder;
                 command.Execute();
             }
 
@@ -396,17 +391,18 @@ namespace WixToolset.Bind
             {
                 Messaging.Instance.OnMessage(WixVerboses.CreatingCabinetFiles());
 
-                CreateCabinetsCommand command = new CreateCabinetsCommand();
+                var command = new CreateCabinetsCommand();
                 command.CabbingThreadCount = this.CabbingThreadCount;
+                command.CabCachePath = this.CabCachePath;
                 command.DefaultCompressionLevel = this.DefaultCompressionLevel;
                 command.Output = this.Output;
-                command.FileManagers = this.FileManagers;
+                command.BackendExtensions = this.BackendExtensions;
                 command.LayoutDirectory = layoutDirectory;
                 command.Compressed = compressed;
                 command.FileRowsByCabinet = filesByCabinetMedia;
                 command.ResolveMedia = this.ResolveMedia;
                 command.TableDefinitions = this.TableDefinitions;
-                command.TempFilesLocation = this.TempFilesLocation;
+                command.TempFilesLocation = this.IntermediateFolder;
                 command.WixMediaTable = this.Output.Tables["WixMedia"];
                 command.Execute();
 
@@ -450,14 +446,14 @@ namespace WixToolset.Bind
                 }
             }
 
-            foreach (BinderExtension extension in this.Extensions)
-            {
-                extension.Finish(this.Output);
-            }
+            //foreach (BinderExtension extension in this.Extensions)
+            //{
+            //    extension.PostBind(this.Context);
+            //}
 
             // generate database file
             Messaging.Instance.OnMessage(WixVerboses.GeneratingDatabase());
-            string tempDatabaseFile = Path.Combine(this.TempFilesLocation, Path.GetFileName(this.OutputPath));
+            string tempDatabaseFile = Path.Combine(this.IntermediateFolder, Path.GetFileName(this.OutputPath));
             this.GenerateDatabase(this.Output, tempDatabaseFile, false, false);
 
             FileTransfer transfer;
@@ -501,14 +497,14 @@ namespace WixToolset.Bind
             }
 
             // inspect the MSI prior to running ICEs
-            InspectorCore inspectorCore = new InspectorCore();
-            foreach (InspectorExtension inspectorExtension in this.InspectorExtensions)
-            {
-                inspectorExtension.Core = inspectorCore;
-                inspectorExtension.InspectDatabase(tempDatabaseFile, pdb);
+            //InspectorCore inspectorCore = new InspectorCore();
+            //foreach (InspectorExtension inspectorExtension in this.InspectorExtensions)
+            //{
+            //    inspectorExtension.Core = inspectorCore;
+            //    inspectorExtension.InspectDatabase(tempDatabaseFile, pdb);
 
-                inspectorExtension.Core = null; // reset.
-            }
+            //    inspectorExtension.Core = null; // reset.
+            //}
 
             if (Messaging.Instance.EncounteredError)
             {
@@ -540,7 +536,7 @@ namespace WixToolset.Bind
             // Process uncompressed files.
             if (!Messaging.Instance.EncounteredError && !this.SuppressLayout && uncompressedFiles.Any())
             {
-                ProcessUncompressedFilesCommand command = new ProcessUncompressedFilesCommand();
+                var command = new ProcessUncompressedFilesCommand();
                 command.Compressed = compressed;
                 command.FileFacades = uncompressedFiles;
                 command.LayoutDirectory = layoutDirectory;
@@ -570,8 +566,8 @@ namespace WixToolset.Bind
                 foreach (Row row in dialogTable.Rows)
                 {
                     string dialog = (string)row[0];
-                    LocalizedControl localizedControl = this.Localizer.GetLocalizedControl(dialog, null);
-                    if (null != localizedControl)
+
+                    if (this.WixVariableResolver.TryGetLocalizedControl(dialog, null, out LocalizedControl localizedControl))
                     {
                         if (CompilerConstants.IntegerNotSet != localizedControl.X)
                         {
@@ -610,8 +606,8 @@ namespace WixToolset.Bind
                 {
                     string dialog = (string)row[0];
                     string control = (string)row[1];
-                    LocalizedControl localizedControl = this.Localizer.GetLocalizedControl(dialog, control);
-                    if (null != localizedControl)
+
+                    if (this.WixVariableResolver.TryGetLocalizedControl(dialog, control, out LocalizedControl localizedControl))
                     {
                         if (CompilerConstants.IntegerNotSet != localizedControl.X)
                         {
@@ -651,10 +647,8 @@ namespace WixToolset.Bind
         /// <param name="allFileRows">True if copying from transform to patch, false the other way.</param>
         private IEnumerable<FileFacade> CopyFromTransformData(Output output)
         {
-            CopyTransformDataCommand command = new CopyTransformDataCommand();
+            var command = new CopyTransformDataCommand();
             command.CopyOutFileRows = true;
-            command.FileManagerCore = this.FileManagerCore;
-            command.FileManagers = this.FileManagers;
             command.Output = output;
             command.TableDefinitions = this.TableDefinitions;
             command.Execute();
@@ -669,35 +663,13 @@ namespace WixToolset.Bind
         /// <param name="allFileRows">True if copying from transform to patch, false the other way.</param>
         private void CopyToTransformData(Output output)
         {
-            CopyTransformDataCommand command = new CopyTransformDataCommand();
+            var command = new CopyTransformDataCommand();
             command.CopyOutFileRows = false;
-            command.FileManagerCore = this.FileManagerCore;
-            command.FileManagers = this.FileManagers;
             command.Output = output;
             command.TableDefinitions = this.TableDefinitions;
             command.Execute();
         }
 
-        /// <summary>
-        /// Takes an id, and demodularizes it (if possible).
-        /// </summary>
-        /// <remarks>
-        /// If the output type is a module, returns a demodularized version of an id. Otherwise, returns the id.
-        /// </remarks>
-        /// <param name="outputType">The type of the output to bind.</param>
-        /// <param name="modularizationGuid">The modularization GUID.</param>
-        /// <param name="id">The id to demodularize.</param>
-        /// <returns>The demodularized id.</returns>
-        internal static string Demodularize(OutputType outputType, string modularizationGuid, string id)
-        {
-            if (OutputType.Module == outputType && id.EndsWith(String.Concat(".", modularizationGuid), StringComparison.Ordinal))
-            {
-                id = id.Substring(0, id.Length - 37);
-            }
-
-            return id;
-        }
-
         private void UpdateMediaSequences(OutputType outputType, IEnumerable<FileFacade> fileFacades, RowDictionary<MediaRow> mediaRows)
         {
             // Calculate sequence numbers and media disk id layout for all file media information objects.
@@ -855,7 +827,7 @@ namespace WixToolset.Bind
                                             continue;
                                         }
 
-                                        string targetName = Installer.GetName((string)row[2], false, true);
+                                        string targetName = Common.GetName((string)row[2], false, true);
                                         directories.Add(row[0], new ResolvedDirectory((string)row[1], targetName));
                                     }
                                 }
@@ -919,7 +891,7 @@ namespace WixToolset.Bind
                                 {
                                     // calculate the key file's canonical target path
                                     string directoryPath = Binder.GetDirectoryPath(directories, componentIdGenSeeds, componentRow.Directory, true);
-                                    string fileName = Installer.GetName(fileRow.FileName, false, true).ToLower(CultureInfo.InvariantCulture);
+                                    string fileName = Common.GetName(fileRow.FileName, false, true).ToLower(CultureInfo.InvariantCulture);
                                     path = Path.Combine(directoryPath, fileName);
 
                                     // find paths that are not canonicalized
@@ -1256,9 +1228,9 @@ namespace WixToolset.Bind
         {
             string layout = null;
 
-            foreach (IBinderFileManager fileManager in this.FileManagers)
+            foreach (var extension in this.BackendExtensions)
             {
-                layout = fileManager.ResolveMedia(mediaRow, mediaLayoutDirectory, layoutDirectory);
+                layout = extension.ResolveMedia(mediaRow, mediaLayoutDirectory, layoutDirectory);
                 if (!String.IsNullOrEmpty(layout))
                 {
                     break;
@@ -1294,16 +1266,15 @@ namespace WixToolset.Bind
         /// <param name="useSubdirectory">Whether to use a subdirectory based on the <paramref name="databaseFile"/> file name for intermediate files.</param>
         private void GenerateDatabase(Output output, string databaseFile, bool keepAddedColumns, bool useSubdirectory)
         {
-            GenerateDatabaseCommand command = new GenerateDatabaseCommand();
+            var command = new GenerateDatabaseCommand();
             command.Extensions = this.Extensions;
-            command.FileManagers = this.FileManagers;
             command.Output = output;
             command.OutputPath = databaseFile;
             command.KeepAddedColumns = keepAddedColumns;
             command.UseSubDirectory = useSubdirectory;
             command.SuppressAddingValidationRows = this.SuppressAddingValidationRows;
             command.TableDefinitions = this.TableDefinitions;
-            command.TempFilesLocation = this.TempFilesLocation;
+            command.TempFilesLocation = this.IntermediateFolder;
             command.Codepage = this.Codepage;
             command.Execute();
         }
diff --git a/src/WixToolset.Core/Bind/Databases/BindSummaryInfoCommand.cs b/src/WixToolset.Core.WindowsInstaller/Bind/BindSummaryInfoCommand.cs
index 95bd4cf0..5471792d 100644
--- a/src/WixToolset.Core/Bind/Databases/BindSummaryInfoCommand.cs
+++ b/src/WixToolset.Core.WindowsInstaller/Bind/BindSummaryInfoCommand.cs
@@ -1,6 +1,6 @@
 // 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.Bind.Databases
+namespace WixToolset.Core.WindowsInstaller.Databases
 {
     using System;
     using System.Globalization;
@@ -9,7 +9,7 @@ namespace WixToolset.Bind.Databases
     /// <summary>
     /// Binds the summary information table of a database.
     /// </summary>
-    internal class BindSummaryInfoCommand : ICommand
+    internal class BindSummaryInfoCommand
     {
         /// <summary>
         /// The output to bind.
diff --git a/src/WixToolset.Core/Bind/BindTransformCommand.cs b/src/WixToolset.Core.WindowsInstaller/Bind/BindTransformCommand.cs
index e909f191..425d1f9c 100644
--- a/src/WixToolset.Core/Bind/BindTransformCommand.cs
+++ b/src/WixToolset.Core.WindowsInstaller/Bind/BindTransformCommand.cs
@@ -1,6 +1,6 @@
 // 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.Bind
+namespace WixToolset.Core.WindowsInstaller.Databases
 {
     using System;
     using System.Collections.Generic;
@@ -11,12 +11,10 @@ namespace WixToolset.Bind
     using WixToolset.Msi;
     using WixToolset.Core.Native;
 
-    internal class BindTransformCommand : ICommand
+    internal class BindTransformCommand
     {
         public IEnumerable<IBinderExtension> Extensions { private get; set; }
 
-        public IEnumerable<IBinderFileManager> FileManagers { private get; set; }
-
         public TableDefinitionCollection TableDefinitions { private get; set; }
 
         public string TempFilesLocation { private get; set; }
@@ -379,10 +377,10 @@ namespace WixToolset.Bind
                 }
             }
 
-            foreach (BinderExtension extension in this.Extensions)
-            {
-                extension.Finish(this.Transform);
-            }
+            //foreach (BinderExtension extension in this.Extensions)
+            //{
+            //    extension.PostBind(this.Context);
+            //}
 
             // Any errors encountered up to this point can cause errors during generation.
             if (Messaging.Instance.EncounteredError)
@@ -437,9 +435,9 @@ namespace WixToolset.Bind
         private bool CompareFiles(string targetFile, string updatedFile)
         {
             bool? compared = null;
-            foreach (IBinderFileManager fileManager in this.FileManagers)
+            foreach (var extension in this.Extensions)
             {
-                compared = fileManager.CompareFiles(targetFile, updatedFile);
+                compared = extension.CompareFiles(targetFile, updatedFile);
                 if (compared.HasValue)
                 {
                     break;
@@ -456,10 +454,9 @@ namespace WixToolset.Bind
 
         private void GenerateDatabase(Output output, string outputPath, bool keepAddedColumns)
         {
-            GenerateDatabaseCommand command = new GenerateDatabaseCommand();
+            var command = new GenerateDatabaseCommand();
             command.Codepage = output.Codepage;
             command.Extensions = this.Extensions;
-            command.FileManagers = this.FileManagers;
             command.KeepAddedColumns = keepAddedColumns;
             command.Output = output;
             command.OutputPath = outputPath;
diff --git a/src/WixToolset.Core/Bind/Databases/CabinetBuilder.cs b/src/WixToolset.Core.WindowsInstaller/Bind/CabinetBuilder.cs
index 2de6ec25..b2cc76fc 100644
--- a/src/WixToolset.Core/Bind/Databases/CabinetBuilder.cs
+++ b/src/WixToolset.Core.WindowsInstaller/Bind/CabinetBuilder.cs
@@ -1,15 +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.
 
-namespace WixToolset.Bind.Databases
+namespace WixToolset.Core.WindowsInstaller.Databases
 {
     using System;
     using System.Collections;
     using System.IO;
     using System.Linq;
     using System.Threading;
-    using WixToolset.Cab;
+    using WixToolset.Core.Bind;
+    using WixToolset.Core.Cab;
     using WixToolset.Data;
-    using WixToolset.Data.Rows;
 
     /// <summary>
     /// Builds cabinets using multiple threads. This implements a thread pool that generates cabinets with multiple
@@ -25,6 +25,7 @@ namespace WixToolset.Bind.Databases
         private IntPtr newCabNamesCallBackAddress;
 
         public int MaximumCabinetSizeForLargeFileSplitting { get; set; }
+
         public int MaximumUncompressedMediaSize { get; set; }
 
         /// <summary>
diff --git a/src/WixToolset.Core.WindowsInstaller/Bind/CabinetResolver.cs b/src/WixToolset.Core.WindowsInstaller/Bind/CabinetResolver.cs
new file mode 100644
index 00000000..df1ccecf
--- /dev/null
+++ b/src/WixToolset.Core.WindowsInstaller/Bind/CabinetResolver.cs
@@ -0,0 +1,122 @@
+// 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.Cab;
+    using WixToolset.Core.Bind;
+    using WixToolset.Data;
+    using WixToolset.Extensibility;
+
+    public class CabinetResolver
+    {
+        public CabinetResolver(string cabCachePath, IEnumerable<IWindowsInstallerBackendExtension> backendExtensions)
+        {
+            this.CabCachePath = cabCachePath;
+
+            this.BackendExtensions = backendExtensions;
+        }
+
+        private string CabCachePath { get; }
+
+        private IEnumerable<IWindowsInstallerBackendExtension> BackendExtensions { get; }
+
+        public ResolvedCabinet ResolveCabinet(string cabinetPath, IEnumerable<FileFacade> fileFacades)
+        {
+            var filesWithPath = fileFacades.Select(f => new BindFileWithPath() { Id = f.File.File, Path = f.WixFile.Source }).ToList();
+
+            ResolvedCabinet resolved = null;
+
+            foreach (var extension in this.BackendExtensions)
+            {
+                resolved = extension.ResolveCabinet(cabinetPath, filesWithPath);
+
+                if (null != resolved)
+                {
+                    return resolved;
+                }
+            }
+
+            // By default cabinet should be built and moved to the suggested location.
+            resolved = new ResolvedCabinet() { BuildOption = CabinetBuildOption.BuildAndMove, Path = cabinetPath };
+
+            // If a cabinet cache path was provided, change the location for the cabinet
+            // to be built to and check if there is a cabinet that can be reused.
+            if (!String.IsNullOrEmpty(this.CabCachePath))
+            {
+                string cabinetName = Path.GetFileName(cabinetPath);
+                resolved.Path = Path.Combine(this.CabCachePath, cabinetName);
+
+                if (CheckFileExists(resolved.Path))
+                {
+                    // Assume that none of the following are true:
+                    // 1. any files are added or removed
+                    // 2. order of files changed or names changed
+                    // 3. modified time changed
+                    bool cabinetValid = true;
+
+                    // Need to force garbage collection of WixEnumerateCab to ensure the handle
+                    // associated with it is closed before it is reused.
+                    using (var wixEnumerateCab = new WixEnumerateCab())
+                    {
+                        List<CabinetFileInfo> fileList = wixEnumerateCab.Enumerate(resolved.Path);
+
+                        if (filesWithPath.Count() != fileList.Count)
+                        {
+                            cabinetValid = false;
+                        }
+                        else
+                        {
+                            int i = 0;
+                            foreach (BindFileWithPath file in filesWithPath)
+                            {
+                                // First check that the file identifiers match because that is quick and easy.
+                                CabinetFileInfo cabFileInfo = fileList[i];
+                                cabinetValid = (cabFileInfo.FileId == file.Id);
+                                if (cabinetValid)
+                                {
+                                    // Still valid so ensure the file sizes are the same.
+                                    FileInfo fileInfo = new FileInfo(file.Path);
+                                    cabinetValid = (cabFileInfo.Size == fileInfo.Length);
+                                    if (cabinetValid)
+                                    {
+                                        // Still valid so ensure the source time stamp hasn't changed. Thus we need
+                                        // to convert the source file time stamp into a cabinet compatible data/time.
+                                        Native.CabInterop.DateTimeToCabDateAndTime(fileInfo.LastWriteTime, out var sourceCabDate, out var sourceCabTime);
+                                        cabinetValid = (cabFileInfo.Date == sourceCabDate && cabFileInfo.Time == sourceCabTime);
+                                    }
+                                }
+
+                                if (!cabinetValid)
+                                {
+                                    break;
+                                }
+
+                                i++;
+                            }
+                        }
+                    }
+
+                    resolved.BuildOption = cabinetValid ? CabinetBuildOption.Copy : CabinetBuildOption.BuildAndCopy;
+                }
+            }
+
+            return resolved;
+        }
+
+        private static bool CheckFileExists(string path)
+        {
+            try
+            {
+                return File.Exists(path);
+            }
+            catch (ArgumentException)
+            {
+                throw new WixException(WixErrors.IllegalCharactersInPath(path));
+            }
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Bind/Databases/CabinetWorkItem.cs b/src/WixToolset.Core.WindowsInstaller/Bind/CabinetWorkItem.cs
index 20241bc9..dcafcd36 100644
--- a/src/WixToolset.Core/Bind/Databases/CabinetWorkItem.cs
+++ b/src/WixToolset.Core.WindowsInstaller/Bind/CabinetWorkItem.cs
@@ -1,8 +1,9 @@
 // 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.Bind.Databases
+namespace WixToolset.Core.WindowsInstaller.Databases
 {
     using System.Collections.Generic;
+    using WixToolset.Core.Bind;
     using WixToolset.Data;
     using WixToolset.Data.Rows;
 
diff --git a/src/WixToolset.Core/Bind/Databases/ConfigurationCallback.cs b/src/WixToolset.Core.WindowsInstaller/Bind/ConfigurationCallback.cs
index 7cb18e0f..d4d3799f 100644
--- a/src/WixToolset.Core/Bind/Databases/ConfigurationCallback.cs
+++ b/src/WixToolset.Core.WindowsInstaller/Bind/ConfigurationCallback.cs
@@ -1,6 +1,6 @@
 // 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.Bind.Databases
+namespace WixToolset.Core.WindowsInstaller.Databases
 {
     using System;
     using System.Collections;
diff --git a/src/WixToolset.Core/Bind/Databases/CopyTransformDataCommand.cs b/src/WixToolset.Core.WindowsInstaller/Bind/CopyTransformDataCommand.cs
index af1ab3b0..6388a352 100644
--- a/src/WixToolset.Core/Bind/Databases/CopyTransformDataCommand.cs
+++ b/src/WixToolset.Core.WindowsInstaller/Bind/CopyTransformDataCommand.cs
@@ -1,6 +1,6 @@
 // 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.Bind.Databases
+namespace WixToolset.Core.WindowsInstaller.Databases
 {
     using System;
     using System.Collections.Generic;
@@ -9,15 +9,14 @@ namespace WixToolset.Bind.Databases
     using WixToolset.Data.Rows;
     using WixToolset.Extensibility;
     using WixToolset.Core.Native;
+    using WixToolset.Core.Bind;
 
-    internal class CopyTransformDataCommand : ICommand
+    internal class CopyTransformDataCommand
     {
         public bool CopyOutFileRows { private get; set; }
 
-        public BinderFileManagerCore FileManagerCore { private get; set; }
-
-        public IEnumerable<IBinderFileManager> FileManagers { private get; set; }
-
+        public IEnumerable<IBinderExtension> Extensions { private get; set; }
+        
         public Output Output { private get; set; }
 
         public TableDefinitionCollection TableDefinitions { private get; set; }
@@ -586,9 +585,10 @@ namespace WixToolset.Bind.Databases
         private bool CompareFiles(string targetFile, string updatedFile)
         {
             bool? compared = null;
-            foreach (IBinderFileManager fileManager in this.FileManagers)
+            foreach (var extension in this.Extensions)
             {
-                compared = fileManager.CompareFiles(targetFile, updatedFile);
+                compared = extension.CompareFiles(targetFile, updatedFile);
+
                 if (compared.HasValue)
                 {
                     break;
diff --git a/src/WixToolset.Core/Bind/Databases/CreateCabinetsCommand.cs b/src/WixToolset.Core.WindowsInstaller/Bind/CreateCabinetsCommand.cs
index 35c8abb4..02015744 100644
--- a/src/WixToolset.Core/Bind/Databases/CreateCabinetsCommand.cs
+++ b/src/WixToolset.Core.WindowsInstaller/Bind/CreateCabinetsCommand.cs
@@ -1,6 +1,6 @@
 // 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.Bind.Databases
+namespace WixToolset.Core.WindowsInstaller.Databases
 {
     using System;
     using System.Collections.Generic;
@@ -9,15 +9,21 @@ namespace WixToolset.Bind.Databases
     using System.Linq;
     using System.Runtime.InteropServices;
     using System.Threading;
+    using WixToolset.Core.Bind;
+    using WixToolset.Core.WindowsInstaller.Bind;
     using WixToolset.Data;
+    using WixToolset.Data.Bind;
     using WixToolset.Data.Rows;
     using WixToolset.Extensibility;
 
     /// <summary>
     /// Creates cabinet files.
     /// </summary>
-    internal class CreateCabinetsCommand : ICommand
+    internal class CreateCabinetsCommand
     {
+        public const int DefaultMaximumUncompressedMediaSize = 200; // Default value is 200 MB
+        public const int MaxValueOfMaxCabSizeForLargeFileSplitting = 2 * 1024; // 2048 MB (i.e. 2 GB)
+
         private List<FileTransfer> fileTransfers;
 
         private FileSplitCabNamesCallback newCabNamesCallBack;
@@ -28,7 +34,7 @@ namespace WixToolset.Bind.Databases
         {
             this.fileTransfers = new List<FileTransfer>();
 
-            this.newCabNamesCallBack = NewCabNamesCallBack;
+            this.newCabNamesCallBack = this.NewCabNamesCallBack;
         }
 
         /// <summary>
@@ -36,6 +42,8 @@ namespace WixToolset.Bind.Databases
         /// </summary>
         public int CabbingThreadCount { private get; set; }
 
+        public string CabCachePath { private get; set; }
+
         public string TempFilesLocation { private get; set; }
 
         /// <summary>
@@ -44,9 +52,9 @@ namespace WixToolset.Bind.Databases
         /// </summary>
         public CompressionLevel DefaultCompressionLevel { private get; set; }
 
-        public Output Output { private get; set; }
+        public IEnumerable<IWindowsInstallerBackendExtension> BackendExtensions { private get; set; }
 
-        public IEnumerable<IBinderFileManager> FileManagers { private get; set; }
+        public Output Output { private get; set; }
 
         public string LayoutDirectory { private get; set; }
 
@@ -60,7 +68,7 @@ namespace WixToolset.Bind.Databases
 
         public Table WixMediaTable { private get; set; }
 
-        public IEnumerable<FileTransfer> FileTransfers { get { return this.fileTransfers; } }
+        public IEnumerable<FileTransfer> FileTransfers => this.fileTransfers;
 
         /// <param name="output">Output to generate image for.</param>
         /// <param name="fileTransfers">Array of files to be transfered.</param>
@@ -204,7 +212,9 @@ namespace WixToolset.Bind.Databases
                 }
             }
 
-            ResolvedCabinet resolvedCabinet = this.ResolveCabinet(tempCabinetFileX, fileFacades);
+            var cabinetResolver = new CabinetResolver(this.CabCachePath, this.BackendExtensions);
+
+            ResolvedCabinet resolvedCabinet = cabinetResolver.ResolveCabinet(tempCabinetFileX, fileFacades);
 
             // create a cabinet work item if it's not being skipped
             if (CabinetBuildOption.BuildAndCopy == resolvedCabinet.BuildOption || CabinetBuildOption.BuildAndMove == resolvedCabinet.BuildOption)
@@ -255,23 +265,23 @@ namespace WixToolset.Bind.Databases
             return cabinetWorkItem;
         }
 
-        private ResolvedCabinet ResolveCabinet(string cabinetPath, IEnumerable<FileFacade> fileFacades)
-        {
-            ResolvedCabinet resolved = null;
+        //private ResolvedCabinet ResolveCabinet(string cabinetPath, IEnumerable<FileFacade> fileFacades)
+        //{
+        //    ResolvedCabinet resolved = null;
 
-            List<BindFileWithPath> filesWithPath = fileFacades.Select(f => new BindFileWithPath() { Id = f.File.File, Path = f.WixFile.Source }).ToList();
+        //    List<BindFileWithPath> filesWithPath = fileFacades.Select(f => new BindFileWithPath() { Id = f.File.File, Path = f.WixFile.Source }).ToList();
 
-            foreach (IBinderFileManager fileManager in this.FileManagers)
-            {
-                resolved = fileManager.ResolveCabinet(cabinetPath, filesWithPath);
-                if (null != resolved)
-                {
-                    break;
-                }
-            }
+        //    foreach (var extension in this.BackendExtensions)
+        //    {
+        //        resolved = extension.ResolveCabinet(cabinetPath, filesWithPath);
+        //        if (null != resolved)
+        //        {
+        //            break;
+        //        }
+        //    }
 
-            return resolved;
-        }
+        //    return resolved;
+        //}
 
         /// <summary>
         /// Delegate for Cabinet Split Callback
@@ -451,7 +461,7 @@ namespace WixToolset.Bind.Databases
                 }
                 catch (OverflowException)
                 {
-                    throw new WixException(WixErrors.MaximumCabinetSizeForLargeFileSplittingTooLarge(null, maxCabSizeForLargeFileInMB, CompilerCore.MaxValueOfMaxCabSizeForLargeFileSplitting));
+                    throw new WixException(WixErrors.MaximumCabinetSizeForLargeFileSplittingTooLarge(null, maxCabSizeForLargeFileInMB, MaxValueOfMaxCabSizeForLargeFileSplitting));
                 }
 
                 try
@@ -482,7 +492,7 @@ namespace WixToolset.Bind.Databases
             else
             {
                 maxCabSizeForLargeFileSplitting = 0;
-                maxUncompressedMediaSize = CompilerCore.DefaultMaximumUncompressedMediaSize;
+                maxUncompressedMediaSize = DefaultMaximumUncompressedMediaSize;
             }
         }
     }
diff --git a/src/WixToolset.Core/Bind/Databases/CreateDeltaPatchesCommand.cs b/src/WixToolset.Core.WindowsInstaller/Bind/CreateDeltaPatchesCommand.cs
index 933a1ea8..767671b8 100644
--- a/src/WixToolset.Core/Bind/Databases/CreateDeltaPatchesCommand.cs
+++ b/src/WixToolset.Core.WindowsInstaller/Bind/CreateDeltaPatchesCommand.cs
@@ -1,18 +1,19 @@
 // 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.Bind.Databases
+namespace WixToolset.Core.WindowsInstaller.Databases
 {
     using System;
     using System.Collections.Generic;
     using System.Globalization;
     using System.IO;
+    using WixToolset.Core.Bind;
     using WixToolset.Data;
     using WixToolset.Data.Rows;
 
     /// <summary>
     /// Creates delta patches and updates the appropriate rows to point to the newly generated patches.
     /// </summary>
-    internal class CreateDeltaPatchesCommand : ICommand
+    internal class CreateDeltaPatchesCommand
     {
         public IEnumerable<FileFacade> FileFacades { private get; set; }
 
@@ -23,7 +24,7 @@ namespace WixToolset.Bind.Databases
         public void Execute()
         {
             bool optimizePatchSizeForLargeFiles = false;
-            PatchAPI.PatchInterop.PatchSymbolFlagsType apiPatchingSymbolFlags = 0;
+            PatchSymbolFlagsType apiPatchingSymbolFlags = 0;
 
             if (null != this.WixPatchIdTable)
             {
@@ -37,7 +38,7 @@ namespace WixToolset.Bind.Databases
 
                     if (null != row[3])
                     {
-                        apiPatchingSymbolFlags = (PatchAPI.PatchInterop.PatchSymbolFlagsType)Convert.ToUInt32(row[3], CultureInfo.InvariantCulture);
+                        apiPatchingSymbolFlags = (PatchSymbolFlagsType)Convert.ToUInt32(row[3], CultureInfo.InvariantCulture);
                     }
                 }
             }
diff --git a/src/WixToolset.Core/Bind/Databases/CreateSpecialPropertiesCommand.cs b/src/WixToolset.Core.WindowsInstaller/Bind/CreateSpecialPropertiesCommand.cs
index 5db2768b..aef130b0 100644
--- a/src/WixToolset.Core/Bind/Databases/CreateSpecialPropertiesCommand.cs
+++ b/src/WixToolset.Core.WindowsInstaller/Bind/CreateSpecialPropertiesCommand.cs
@@ -1,13 +1,13 @@
 // 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.Bind.Databases
+namespace WixToolset.Core.WindowsInstaller.Databases
 {
     using System;
     using System.Collections.Generic;
     using WixToolset.Data;
     using WixToolset.Data.Rows;
 
-    internal class CreateSpecialPropertiesCommand : ICommand
+    internal class CreateSpecialPropertiesCommand
     {
         public Table PropertyTable { private get; set; }
 
diff --git a/src/WixToolset.Core/Bind/Databases/ExtractMergeModuleFilesCommand.cs b/src/WixToolset.Core.WindowsInstaller/Bind/ExtractMergeModuleFilesCommand.cs
index bee1488b..ae76037d 100644
--- a/src/WixToolset.Core/Bind/Databases/ExtractMergeModuleFilesCommand.cs
+++ b/src/WixToolset.Core.WindowsInstaller/Bind/ExtractMergeModuleFilesCommand.cs
@@ -1,6 +1,6 @@
 // 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.Bind.Databases
+namespace WixToolset.Core.WindowsInstaller.Databases
 {
     using System;
     using System.Collections.Generic;
@@ -9,17 +9,18 @@ namespace WixToolset.Bind.Databases
     using System.IO;
     using System.Linq;
     using System.Runtime.InteropServices;
-    using WixToolset.Cab;
     using WixToolset.Data;
     using WixToolset.Data.Rows;
     using WixToolset.MergeMod;
     using WixToolset.Msi;
     using WixToolset.Core.Native;
+    using WixToolset.Core.Bind;
+    using WixToolset.Core.Cab;
 
     /// <summary>
     /// Retrieve files information and extract them from merge modules.
     /// </summary>
-    internal class ExtractMergeModuleFilesCommand : ICommand
+    internal class ExtractMergeModuleFilesCommand
     {
         public IEnumerable<FileFacade> FileFacades { private get; set; }
 
@@ -193,7 +194,7 @@ namespace WixToolset.Bind.Databases
                 string mergeIdPath = String.Concat(this.TempFilesLocation, Path.DirectorySeparatorChar, "MergeId.", safeMergeId);
                 Directory.CreateDirectory(mergeIdPath);
 
-                using (WixExtractCab extractCab = new WixExtractCab())
+                using (var extractCab = new WixExtractCab())
                 {
                     try
                     {
diff --git a/src/WixToolset.Core/Bind/GenerateDatabaseCommand.cs b/src/WixToolset.Core.WindowsInstaller/Bind/GenerateDatabaseCommand.cs
index fdf1ab32..26d254f2 100644
--- a/src/WixToolset.Core/Bind/GenerateDatabaseCommand.cs
+++ b/src/WixToolset.Core.WindowsInstaller/Bind/GenerateDatabaseCommand.cs
@@ -1,6 +1,6 @@
 // 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.Bind
+namespace WixToolset.Core.WindowsInstaller.Databases
 {
     using System;
     using System.Collections.Generic;
@@ -13,14 +13,12 @@ namespace WixToolset.Bind
     using WixToolset.Msi;
     using WixToolset.Core.Native;
 
-    internal class GenerateDatabaseCommand : ICommand
+    internal class GenerateDatabaseCommand 
     {
         public int Codepage { private get; set; }
 
         public IEnumerable<IBinderExtension> Extensions { private get; set; }
 
-        public IEnumerable<IBinderFileManager> FileManagers { private get; set; }
-
         /// <summary>
         /// Whether to keep columns added in a transform.
         /// </summary>
@@ -295,7 +293,6 @@ namespace WixToolset.Bind
         {
             BindTransformCommand command = new BindTransformCommand();
             command.Extensions = this.Extensions;
-            command.FileManagers = this.FileManagers;
             command.TempFilesLocation = this.TempFilesLocation;
             command.Transform = transform;
             command.OutputPath = outputPath;
diff --git a/src/WixToolset.Core/Bind/Databases/GetFileFacadesCommand.cs b/src/WixToolset.Core.WindowsInstaller/Bind/GetFileFacadesCommand.cs
index b6bcd3af..caf8b7a7 100644
--- a/src/WixToolset.Core/Bind/Databases/GetFileFacadesCommand.cs
+++ b/src/WixToolset.Core.WindowsInstaller/Bind/GetFileFacadesCommand.cs
@@ -1,15 +1,16 @@
 // 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.Bind.Databases
+namespace WixToolset.Core.WindowsInstaller.Databases
 {
     using System;
     using System.Collections.Generic;
     using System.Globalization;
     using System.Linq;
+    using WixToolset.Core.Bind;
     using WixToolset.Data;
     using WixToolset.Data.Rows;
 
-    internal class GetFileFacadesCommand : ICommand
+    internal class GetFileFacadesCommand
     {
         public Table FileTable { private get; set; }
 
diff --git a/src/WixToolset.Core/Bind/Databases/MergeModulesCommand.cs b/src/WixToolset.Core.WindowsInstaller/Bind/MergeModulesCommand.cs
index 035ef059..624cbb43 100644
--- a/src/WixToolset.Core/Bind/Databases/MergeModulesCommand.cs
+++ b/src/WixToolset.Core.WindowsInstaller/Bind/MergeModulesCommand.cs
@@ -1,6 +1,6 @@
 // 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.Bind.Databases
+namespace WixToolset.Core.WindowsInstaller.Databases
 {
     using System;
     using System.Collections.Generic;
@@ -20,11 +20,12 @@ namespace WixToolset.Bind.Databases
     using WixToolset.MergeMod;
     using WixToolset.Msi;
     using WixToolset.Core.Native;
+    using WixToolset.Core.Bind;
 
     /// <summary>
     /// Update file information.
     /// </summary>
-    internal class MergeModulesCommand : ICommand
+    internal class MergeModulesCommand
     {
         public IEnumerable<FileFacade> FileFacades { private get; set; }
 
diff --git a/src/WixToolset.Core/Bind/Databases/ProcessUncompressedFilesCommand.cs b/src/WixToolset.Core.WindowsInstaller/Bind/ProcessUncompressedFilesCommand.cs
index dd7b85b7..b3c09b9e 100644
--- a/src/WixToolset.Core/Bind/Databases/ProcessUncompressedFilesCommand.cs
+++ b/src/WixToolset.Core.WindowsInstaller/Bind/ProcessUncompressedFilesCommand.cs
@@ -1,6 +1,6 @@
 // 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.Bind.Databases
+namespace WixToolset.Core.WindowsInstaller.Databases
 {
     using System;
     using System.Collections;
@@ -10,11 +10,14 @@ namespace WixToolset.Bind.Databases
     using WixToolset.Data.Rows;
     using WixToolset.Msi;
     using WixToolset.Core.Native;
+    using WixToolset.Bind;
+    using WixToolset.Core.Bind;
+    using WixToolset.Data.Bind;
 
     /// <summary>
     /// Defines the file transfers necessary to layout the uncompressed files.
     /// </summary>
-    internal class ProcessUncompressedFilesCommand : ICommand
+    internal class ProcessUncompressedFilesCommand
     {
         public string DatabasePath { private get; set; }
 
@@ -55,7 +58,7 @@ namespace WixToolset.Bind.Databases
                                 break;
                             }
 
-                            string sourceName = Installer.GetName(directoryRecord.GetString(3), true, this.LongNamesInImage);
+                            string sourceName = Common.GetName(directoryRecord.GetString(3), true, this.LongNamesInImage);
 
                             directories.Add(directoryRecord.GetString(1), new ResolvedDirectory(directoryRecord.GetString(2), sourceName));
                         }
diff --git a/src/WixToolset.Core/Bind/Databases/UpdateControlTextCommand.cs b/src/WixToolset.Core.WindowsInstaller/Bind/UpdateControlTextCommand.cs
index 9e17ee02..7da32206 100644
--- a/src/WixToolset.Core/Bind/Databases/UpdateControlTextCommand.cs
+++ b/src/WixToolset.Core.WindowsInstaller/Bind/UpdateControlTextCommand.cs
@@ -1,13 +1,13 @@
 // 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.Bind.Databases
+namespace WixToolset.Core.WindowsInstaller.Databases
 {
     using System;
     using System.IO;
     using WixToolset.Data;
     using WixToolset.Data.Rows;
 
-    internal class UpdateControlTextCommand : ICommand
+    internal class UpdateControlTextCommand
     {
         public Table BBControlTable { private get; set; }
 
diff --git a/src/WixToolset.Core/Bind/Databases/UpdateFileFacadesCommand.cs b/src/WixToolset.Core.WindowsInstaller/Bind/UpdateFileFacadesCommand.cs
index 36818afa..cd9444ee 100644
--- a/src/WixToolset.Core/Bind/Databases/UpdateFileFacadesCommand.cs
+++ b/src/WixToolset.Core.WindowsInstaller/Bind/UpdateFileFacadesCommand.cs
@@ -1,6 +1,6 @@
 // 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.Bind.Databases
+namespace WixToolset.Core.WindowsInstaller.Databases
 {
     using System;
     using System.Collections.Generic;
@@ -12,6 +12,7 @@ namespace WixToolset.Bind.Databases
     using System.Xml;
     using System.Xml.XPath;
     using WixToolset.Clr.Interop;
+    using WixToolset.Core.Bind;
     using WixToolset.Data;
     using WixToolset.Data.Rows;
     using WixToolset.Msi;
@@ -19,7 +20,7 @@ namespace WixToolset.Bind.Databases
     /// <summary>
     /// Update file information.
     /// </summary>
-    internal class UpdateFileFacadesCommand : ICommand
+    internal class UpdateFileFacadesCommand
     {
         public IEnumerable<FileFacade> FileFacades { private get; set; }
 
@@ -52,17 +53,17 @@ namespace WixToolset.Bind.Databases
             }
             catch (ArgumentException)
             {
-                Messaging.Instance.OnMessage(WixErrors.InvalidFileName(file.File.SourceLineNumbers, file.WixFile.Source));
+                Messaging.Instance.OnMessage(WixDataErrors.InvalidFileName(file.File.SourceLineNumbers, file.WixFile.Source));
                 return;
             }
             catch (PathTooLongException)
             {
-                Messaging.Instance.OnMessage(WixErrors.InvalidFileName(file.File.SourceLineNumbers, file.WixFile.Source));
+                Messaging.Instance.OnMessage(WixDataErrors.InvalidFileName(file.File.SourceLineNumbers, file.WixFile.Source));
                 return;
             }
             catch (NotSupportedException)
             {
-                Messaging.Instance.OnMessage(WixErrors.InvalidFileName(file.File.SourceLineNumbers, file.WixFile.Source));
+                Messaging.Instance.OnMessage(WixDataErrors.InvalidFileName(file.File.SourceLineNumbers, file.WixFile.Source));
                 return;
             }
 
@@ -195,13 +196,13 @@ namespace WixToolset.Bind.Databases
                 {
                     if (!String.IsNullOrEmpty(file.File.Version))
                     {
-                        string key = String.Format(CultureInfo.InvariantCulture, "fileversion.{0}", BindDatabaseCommand.Demodularize(this.Output.Type, this.ModularizationGuid, file.File.File));
+                        string key = String.Format(CultureInfo.InvariantCulture, "fileversion.{0}", Common.Demodularize(this.Output.Type, this.ModularizationGuid, file.File.File));
                         this.VariableCache[key] = file.File.Version;
                     }
 
                     if (!String.IsNullOrEmpty(file.File.Language))
                     {
-                        string key = String.Format(CultureInfo.InvariantCulture, "filelanguage.{0}", BindDatabaseCommand.Demodularize(this.Output.Type, ModularizationGuid, file.File.File));
+                        string key = String.Format(CultureInfo.InvariantCulture, "filelanguage.{0}", Common.Demodularize(this.Output.Type, ModularizationGuid, file.File.File));
                         this.VariableCache[key] = file.File.Language;
                     }
                 }
@@ -326,7 +327,7 @@ namespace WixToolset.Bind.Databases
                 // add the assembly name to the information cache
                 if (null != this.VariableCache)
                 {
-                    string fileId = BindDatabaseCommand.Demodularize(this.Output.Type, this.ModularizationGuid, file.File.File);
+                    string fileId = Common.Demodularize(this.Output.Type, this.ModularizationGuid, file.File.File);
                     string key = String.Concat("assemblyfullname.", fileId);
                     string assemblyName = String.Concat(assemblyNameValues["name"], ", version=", assemblyNameValues["version"], ", culture=", assemblyNameValues["culture"], ", publicKeyToken=", String.IsNullOrEmpty(assemblyNameValues["publicKeyToken"]) ? "null" : assemblyNameValues["publicKeyToken"]);
                     if (assemblyNameValues.ContainsKey("processorArchitecture"))
@@ -523,7 +524,7 @@ namespace WixToolset.Bind.Databases
 
                 if (this.VariableCache != null)
                 {
-                    string key = String.Format(CultureInfo.InvariantCulture, "assembly{0}.{1}", name, BindDatabaseCommand.Demodularize(this.Output.Type, this.ModularizationGuid, file.File.File)).ToLowerInvariant();
+                    string key = String.Format(CultureInfo.InvariantCulture, "assembly{0}.{1}", name, Common.Demodularize(this.Output.Type, this.ModularizationGuid, file.File.File)).ToLowerInvariant();
                     this.VariableCache[key] = (string)assemblyNameRow[2];
                 }
             }
diff --git a/src/WixToolset.Core/CLR/Interop/CLRInterop.cs b/src/WixToolset.Core.WindowsInstaller/CLR/Interop/CLRInterop.cs
index 4157f23a..4157f23a 100644
--- a/src/WixToolset.Core/CLR/Interop/CLRInterop.cs
+++ b/src/WixToolset.Core.WindowsInstaller/CLR/Interop/CLRInterop.cs
diff --git a/src/WixToolset.Core/Differ.cs b/src/WixToolset.Core.WindowsInstaller/Differ.cs
index 71a64327..bdd06d32 100644
--- a/src/WixToolset.Core/Differ.cs
+++ b/src/WixToolset.Core.WindowsInstaller/Differ.cs
@@ -6,6 +6,7 @@ namespace WixToolset
     using System.Collections;
     using System.Collections.Generic;
     using System.Globalization;
+    using WixToolset.Core;
     using WixToolset.Data;
     using WixToolset.Data.Rows;
     using WixToolset.Extensibility;
@@ -155,17 +156,6 @@ namespace WixToolset
                 this.UpdateTransformSummaryInformationTable(summaryInfoTable, validationFlags);
             }
 
-            // inspect the transform
-            InspectorCore inspectorCore = new InspectorCore();
-            foreach (InspectorExtension inspectorExtension in this.inspectorExtensions)
-            {
-                inspectorExtension.Core = inspectorCore;
-                inspectorExtension.InspectOutput(transform);
-
-                // reset
-                inspectorExtension.Core = null;
-            }
-
             return transform;
         }
 
diff --git a/src/WixToolset.Core.WindowsInstaller/Inscribe/InscribeMsiPackageCommand.cs b/src/WixToolset.Core.WindowsInstaller/Inscribe/InscribeMsiPackageCommand.cs
new file mode 100644
index 00000000..40901d7c
--- /dev/null
+++ b/src/WixToolset.Core.WindowsInstaller/Inscribe/InscribeMsiPackageCommand.cs
@@ -0,0 +1,282 @@
+// 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.Inscribe
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.IO;
+    using System.Runtime.InteropServices;
+    using System.Security.Cryptography.X509Certificates;
+    using WixToolset.Core.Native;
+    using WixToolset.Data;
+    using WixToolset.Extensibility;
+    using WixToolset.Msi;
+
+    internal class InscribeMsiPackageCommand
+    {
+        public InscribeMsiPackageCommand(IInscribeContext context)
+        {
+            this.Context = context;
+            this.TableDefinitions = WindowsInstallerStandard.GetTableDefinitions();
+        }
+
+        private IInscribeContext Context { get; }
+
+        private TableDefinitionCollection TableDefinitions { get; }
+
+        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;
+
+            FileAttributes attributes = File.GetAttributes(this.Context.InputFilePath);
+            if (FileAttributes.ReadOnly == (attributes & FileAttributes.ReadOnly))
+            {
+                this.Context.Messaging.OnMessage(WixErrors.ReadOnlyOutputFile(this.Context.InputFilePath));
+                return shouldCommit;
+            }
+
+            using (Database 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;
+
+                // list of certificates for this database (hash/identifier)
+                Dictionary<string, string> certificates = new Dictionary<string, string>();
+
+                // Reset the in-memory tables for this new database
+                Table digitalSignatureTable = new Table(null, this.TableDefinitions["MsiDigitalSignature"]);
+                Table digitalCertificateTable = new Table(null, 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'"))
+                    {
+                        while (true)
+                        {
+                            using (Record digitalSignatureRecord = digitalSignatureView.Fetch())
+                            {
+                                if (null == digitalSignatureRecord)
+                                {
+                                    break;
+                                }
+
+                                Row digitalSignatureRow = null;
+                                digitalSignatureRow = digitalSignatureTable.CreateRow(null);
+
+                                string table = digitalSignatureRecord.GetString(0);
+                                string signObject = digitalSignatureRecord.GetString(1);
+
+                                digitalSignatureRow[0] = table;
+                                digitalSignatureRow[1] = signObject;
+                                digitalSignatureRow[2] = digitalSignatureRecord.GetString(2);
+
+                                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");
+
+                                    Directory.CreateDirectory(hashPath);
+                                    hashPath = Path.Combine(hashPath, hashFileName);
+
+                                    using (FileStream fs = File.Create(hashPath))
+                                    {
+                                        int bytesRead;
+                                        byte[] buffer = new byte[1024 * 4];
+
+                                        while (0 != (bytesRead = digitalSignatureRecord.GetStream(3, buffer, buffer.Length)))
+                                        {
+                                            fs.Write(buffer, 0, bytesRead);
+                                        }
+                                    }
+
+                                    digitalSignatureRow[3] = hashFileName;
+                                }
+                            }
+                        }
+                    }
+                }
+
+                // If any digital certificates exist, extract and preserve them
+                if (database.TableExists("MsiDigitalCertificate"))
+                {
+                    using (View digitalCertificateView = database.OpenExecuteView("SELECT * FROM `MsiDigitalCertificate`"))
+                    {
+                        while (true)
+                        {
+                            using (Record digitalCertificateRecord = digitalCertificateView.Fetch())
+                            {
+                                if (null == digitalCertificateRecord)
+                                {
+                                    break;
+                                }
+
+                                string 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");
+                                Directory.CreateDirectory(certPath);
+                                certPath = Path.Combine(certPath, string.Concat(certificateId, ".cer"));
+
+                                using (FileStream fs = File.Create(certPath))
+                                {
+                                    int bytesRead;
+                                    byte[] buffer = new byte[1024 * 4];
+
+                                    while (0 != (bytesRead = digitalCertificateRecord.GetStream(2, buffer, buffer.Length)))
+                                    {
+                                        fs.Write(buffer, 0, bytesRead);
+                                    }
+                                }
+
+                                // Add it to our "add to MsiDigitalCertificate" table dictionary
+                                Row 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");
+
+                                // Load the cert to get it's thumbprint
+                                X509Certificate cert = X509Certificate.CreateFromCertFile(certPath);
+                                X509Certificate2 cert2 = new X509Certificate2(cert);
+
+                                certificates.Add(cert2.Thumbprint, certificateId);
+                            }
+                        }
+                    }
+                }
+
+                using (View mediaView = database.OpenExecuteView("SELECT * FROM `Media`"))
+                {
+                    while (true)
+                    {
+                        using (Record mediaRecord = mediaView.Fetch())
+                        {
+                            if (null == mediaRecord)
+                            {
+                                break;
+                            }
+
+                            X509Certificate2 cert2 = null;
+                            Row digitalSignatureRow = null;
+
+                            string 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);
+
+                            // If the cabs aren't there, throw an error but continue to catch the other errors
+                            if (!File.Exists(cabPath))
+                            {
+                                this.Context.Messaging.OnMessage(WixErrors.WixFileNotFound(cabPath));
+                                continue;
+                            }
+
+                            try
+                            {
+                                // Get the certificate from the cab
+                                X509Certificate signedFileCert = X509Certificate.CreateFromSignedFile(cabPath);
+                                cert2 = new X509Certificate2(signedFileCert);
+                            }
+                            catch (System.Security.Cryptography.CryptographicException e)
+                            {
+                                uint 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
+                                {
+                                    foundUnsignedExternals = true;
+                                    continue;
+                                }
+
+                                // todo: exactly which HRESULT corresponds to this issue?
+                                // If it's one of these exact platforms, warn the user that it may be due to their OS.
+                                if ((5 == Environment.OSVersion.Version.Major && 2 == Environment.OSVersion.Version.Minor) || // W2K3
+                                    (5 == Environment.OSVersion.Version.Major && 1 == Environment.OSVersion.Version.Minor)) // XP
+                                {
+                                    this.Context.Messaging.OnMessage(WixErrors.UnableToGetAuthenticodeCertOfFileDownlevelOS(cabPath, String.Format(CultureInfo.InvariantCulture, "HRESULT: 0x{0:x8}", HResult)));
+                                }
+                                else // otherwise, generic error
+                                {
+                                    this.Context.Messaging.OnMessage(WixErrors.UnableToGetAuthenticodeCertOfFile(cabPath, String.Format(CultureInfo.InvariantCulture, "HRESULT: 0x{0:x8}", HResult)));
+                                }
+                            }
+
+                            // If we haven't added this cert to the MsiDigitalCertificate table, set it up to be added
+                            if (!certificates.ContainsKey(cert2.Thumbprint))
+                            {
+                                // generate a stable identifier
+                                string certificateGeneratedId = Common.GenerateIdentifier("cer", cert2.Thumbprint);
+
+                                // Add it to our "add to MsiDigitalCertificate" table dictionary
+                                Row 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");
+                                Directory.CreateDirectory(certPath);
+                                certPath = Path.Combine(certPath, string.Concat(cert2.Thumbprint, ".cer"));
+                                File.Delete(certPath);
+
+                                using (BinaryWriter 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");
+
+                                certificates.Add(cert2.Thumbprint, certificateGeneratedId);
+                            }
+
+                            digitalSignatureRow = digitalSignatureTable.CreateRow(null);
+
+                            digitalSignatureRow[0] = "Media";
+                            digitalSignatureRow[1] = cabId;
+                            digitalSignatureRow[2] = certificates[cert2.Thumbprint];
+                        }
+                    }
+                }
+
+                if (digitalCertificateTable.Rows.Count > 0)
+                {
+                    database.ImportTable(codepage, digitalCertificateTable, this.Context.IntermediateFolder, true);
+                    shouldCommit = true;
+                }
+
+                if (digitalSignatureTable.Rows.Count > 0)
+                {
+                    database.ImportTable(codepage, digitalSignatureTable, this.Context.IntermediateFolder, true);
+                    shouldCommit = true;
+                }
+
+                // TODO: if we created the table(s), then we should add the _Validation records for them.
+
+                certificates = null;
+
+                // If we did find external cabs but none of them were signed, give a warning
+                if (foundUnsignedExternals)
+                {
+                    this.Context.Messaging.OnMessage(WixWarnings.ExternalCabsAreNotSigned(this.Context.InputFilePath));
+                }
+
+                if (shouldCommit)
+                {
+                    database.Commit();
+                }
+            }
+
+            return shouldCommit;
+        }
+    }
+}
diff --git a/src/WixToolset.Core/MergeMod/NativeMethods.cs b/src/WixToolset.Core.WindowsInstaller/MergeMod/NativeMethods.cs
index daf259b4..daf259b4 100644
--- a/src/WixToolset.Core/MergeMod/NativeMethods.cs
+++ b/src/WixToolset.Core.WindowsInstaller/MergeMod/NativeMethods.cs
diff --git a/src/WixToolset.Core/Msi/Database.cs b/src/WixToolset.Core.WindowsInstaller/Msi/Database.cs
index 801ebdde..801ebdde 100644
--- a/src/WixToolset.Core/Msi/Database.cs
+++ b/src/WixToolset.Core.WindowsInstaller/Msi/Database.cs
diff --git a/src/WixToolset.Core/Msi/Installer.cs b/src/WixToolset.Core.WindowsInstaller/Msi/Installer.cs
index 3beb26f4..f8bce602 100644
--- a/src/WixToolset.Core/Msi/Installer.cs
+++ b/src/WixToolset.Core.WindowsInstaller/Msi/Installer.cs
@@ -359,126 +359,5 @@ namespace WixToolset.Msi
         {
             return MsiInterop.MsiSetInternalUI(uiLevel, ref hwnd);
         }
-
-        /// <summary>
-        /// Get the source/target and short/long file names from an MSI Filename column.
-        /// </summary>
-        /// <param name="value">The Filename value.</param>
-        /// <returns>An array of strings of length 4.  The contents are: short target, long target, short source, and long source.</returns>
-        /// <remarks>
-        /// If any particular file name part is not parsed, its set to null in the appropriate location of the returned array of strings.
-        /// However, the returned array will always be of length 4.
-        /// </remarks>
-        internal static string[] GetNames(string value)
-        {
-            string[] names = new string[4];
-            int targetSeparator = value.IndexOf(":", StringComparison.Ordinal);
-
-            // split source and target
-            string sourceName = null;
-            string targetName = value;
-            if (0 <= targetSeparator)
-            {
-                sourceName = value.Substring(targetSeparator + 1);
-                targetName = value.Substring(0, targetSeparator);
-            }
-
-            // split the source short and long names
-            string sourceLongName = null;
-            if (null != sourceName)
-            {
-                int sourceLongNameSeparator = sourceName.IndexOf("|", StringComparison.Ordinal);
-                if (0 <= sourceLongNameSeparator)
-                {
-                    sourceLongName = sourceName.Substring(sourceLongNameSeparator + 1);
-                    sourceName = sourceName.Substring(0, sourceLongNameSeparator);
-                }
-            }
-
-            // split the target short and long names
-            int targetLongNameSeparator = targetName.IndexOf("|", StringComparison.Ordinal);
-            string targetLongName = null;
-            if (0 <= targetLongNameSeparator)
-            {
-                targetLongName = targetName.Substring(targetLongNameSeparator + 1);
-                targetName = targetName.Substring(0, targetLongNameSeparator);
-            }
-
-            // remove the long source name when its identical to the long source name
-            if (null != sourceName && sourceName == sourceLongName)
-            {
-                sourceLongName = null;
-            }
-
-            // remove the long target name when its identical to the long target name
-            if (null != targetName && targetName == targetLongName)
-            {
-                targetLongName = null;
-            }
-
-            // remove the source names when they are identical to the target names
-            if (sourceName == targetName && sourceLongName == targetLongName)
-            {
-                sourceName = null;
-                sourceLongName = null;
-            }
-
-            // target name(s)
-            if ("." != targetName)
-            {
-                names[0] = targetName;
-            }
-
-            if (null != targetLongName && "." != targetLongName)
-            {
-                names[1] = targetLongName;
-            }
-
-            // source name(s)
-            if (null != sourceName)
-            {
-                names[2] = sourceName;
-            }
-
-            if (null != sourceLongName && "." != sourceLongName)
-            {
-                names[3] = sourceLongName;
-            }
-
-            return names;
-        }
-
-        /// <summary>
-        /// Get a source/target and short/long file name from an MSI Filename column.
-        /// </summary>
-        /// <param name="value">The Filename value.</param>
-        /// <param name="source">true to get a source name; false to get a target name</param>
-        /// <param name="longName">true to get a long name; false to get a short name</param>
-        /// <returns>The name.</returns>
-        internal static string GetName(string value, bool source, bool longName)
-        {
-            string[] names = GetNames(value);
-
-            if (source)
-            {
-                if (longName && null != names[3])
-                {
-                    return names[3];
-                }
-                else if (null != names[2])
-                {
-                    return names[2];
-                }
-            }
-
-            if (longName && null != names[1])
-            {
-                return names[1];
-            }
-            else
-            {
-                return names[0];
-            }
-        }
     }
 }
diff --git a/src/WixToolset.Core/Msi/Interop/MsiInterop.cs b/src/WixToolset.Core.WindowsInstaller/Msi/Interop/MsiInterop.cs
index 054289ee..054289ee 100644
--- a/src/WixToolset.Core/Msi/Interop/MsiInterop.cs
+++ b/src/WixToolset.Core.WindowsInstaller/Msi/Interop/MsiInterop.cs
diff --git a/src/WixToolset.Core/Msi/MsiException.cs b/src/WixToolset.Core.WindowsInstaller/Msi/MsiException.cs
index b33bf27a..b33bf27a 100644
--- a/src/WixToolset.Core/Msi/MsiException.cs
+++ b/src/WixToolset.Core.WindowsInstaller/Msi/MsiException.cs
diff --git a/src/WixToolset.Core/Msi/MsiHandle.cs b/src/WixToolset.Core.WindowsInstaller/Msi/MsiHandle.cs
index 6d2dc984..6d2dc984 100644
--- a/src/WixToolset.Core/Msi/MsiHandle.cs
+++ b/src/WixToolset.Core.WindowsInstaller/Msi/MsiHandle.cs
diff --git a/src/WixToolset.Core/Msi/Record.cs b/src/WixToolset.Core.WindowsInstaller/Msi/Record.cs
index 438aa3b0..438aa3b0 100644
--- a/src/WixToolset.Core/Msi/Record.cs
+++ b/src/WixToolset.Core.WindowsInstaller/Msi/Record.cs
diff --git a/src/WixToolset.Core/Msi/Session.cs b/src/WixToolset.Core.WindowsInstaller/Msi/Session.cs
index d3a19711..d3a19711 100644
--- a/src/WixToolset.Core/Msi/Session.cs
+++ b/src/WixToolset.Core.WindowsInstaller/Msi/Session.cs
diff --git a/src/WixToolset.Core/Msi/SummaryInformation.cs b/src/WixToolset.Core.WindowsInstaller/Msi/SummaryInformation.cs
index 39949db6..26831731 100644
--- a/src/WixToolset.Core/Msi/SummaryInformation.cs
+++ b/src/WixToolset.Core.WindowsInstaller/Msi/SummaryInformation.cs
@@ -3,11 +3,8 @@
 namespace WixToolset.Msi
 {
     using System;
-    using System.ComponentModel;
-    using System.Diagnostics.CodeAnalysis;
     using System.Globalization;
     using System.Text;
-    using System.Runtime.InteropServices;
     using FILETIME = System.Runtime.InteropServices.ComTypes.FILETIME;
     using WixToolset.Core.Native;
 
@@ -245,79 +242,4 @@ namespace WixToolset.Msi
             }
         }
     }
-
-    /// <summary>
-    /// Summary information values for the CharCount property in transforms.
-    /// </summary>
-    [Flags]
-    [SuppressMessage("Microsoft.Naming", "CA1711:IdentifiersShouldNotHaveIncorrectSuffix")]
-    public enum TransformFlags
-    {
-        /// <summary>Ignore error when adding a row that exists.</summary>
-        ErrorAddExistingRow = 0x1,
-
-        /// <summary>Ignore error when deleting a row that does not exist.</summary>
-        ErrorDeleteMissingRow = 0x2,
-
-        /// <summary>Ignore error when adding a table that exists. </summary>
-        ErrorAddExistingTable = 0x4,
-
-        /// <summary>Ignore error when deleting a table that does not exist. </summary>
-        ErrorDeleteMissingTable = 0x8,
-
-        /// <summary>Ignore error when updating a row that does not exist. </summary>
-        ErrorUpdateMissingRow = 0x10,
-
-        /// <summary>Ignore error when transform and database code pages do not match, and their code pages are neutral.</summary>
-        ErrorChangeCodePage = 0x20,
-
-        /// <summary>Default language must match base database. </summary>
-        ValidateLanguage = 0x10000,
-
-        /// <summary>Product must match base database.</summary>
-        ValidateProduct = 0x20000,
-
-        /// <summary>Check major version only. </summary>
-        ValidateMajorVersion = 0x80000,
-
-        /// <summary>Check major and minor versions only. </summary>
-        ValidateMinorVersion = 0x100000,
-
-        /// <summary>Check major, minor, and update versions.</summary>
-        ValidateUpdateVersion = 0x200000,
-
-        /// <summary>Installed version lt base version. </summary>
-        ValidateNewLessBaseVersion = 0x400000,
-
-        /// <summary>Installed version lte base version. </summary>
-        ValidateNewLessEqualBaseVersion = 0x800000,
-
-        /// <summary>Installed version eq base version. </summary>
-        ValidateNewEqualBaseVersion = 0x1000000,
-
-        /// <summary>Installed version gte base version.</summary>
-        ValidateNewGreaterEqualBaseVersion = 0x2000000,
-
-        /// <summary>Installed version gt base version.</summary>
-        ValidateNewGreaterBaseVersion = 0x4000000,
-
-        /// <summary>UpgradeCode must match base database.</summary>
-        ValidateUpgradeCode = 0x8000000,
-
-        /// <summary>Masks all version checks on ProductVersion.</summary>
-        ProductVersionMask = ValidateMajorVersion | ValidateMinorVersion | ValidateUpdateVersion,
-
-        /// <summary>Masks all operations on ProductVersion.</summary>
-        ProductVersionOperatorMask = ValidateNewLessBaseVersion | ValidateNewLessEqualBaseVersion | ValidateNewEqualBaseVersion | ValidateNewGreaterEqualBaseVersion | ValidateNewGreaterBaseVersion,
-
-        /// <summary>Default value for instance transforms.</summary>
-        InstanceTransformDefault = ErrorAddExistingRow | ErrorDeleteMissingRow | ErrorAddExistingTable | ErrorDeleteMissingTable | ErrorUpdateMissingRow | ErrorChangeCodePage | ValidateProduct | ValidateUpdateVersion | ValidateNewGreaterEqualBaseVersion,
-
-        /// <summary>Default value for language transforms.</summary>
-        LanguageTransformDefault = ErrorAddExistingRow | ErrorDeleteMissingRow | ErrorAddExistingTable | ErrorDeleteMissingTable | ErrorUpdateMissingRow | ErrorChangeCodePage | ValidateProduct,
-
-        /// <summary>Default value for patch transforms.</summary>
-        PatchTransformDefault = ErrorAddExistingRow | ErrorDeleteMissingRow | ErrorAddExistingTable | ErrorDeleteMissingTable | ErrorUpdateMissingRow | ValidateProduct | ValidateUpdateVersion | ValidateNewEqualBaseVersion | ValidateUpgradeCode,
-    }
-
 }
diff --git a/src/WixToolset.Core/Msi/View.cs b/src/WixToolset.Core.WindowsInstaller/Msi/View.cs
index d6542824..d6542824 100644
--- a/src/WixToolset.Core/Msi/View.cs
+++ b/src/WixToolset.Core.WindowsInstaller/Msi/View.cs
diff --git a/src/WixToolset.Core.WindowsInstaller/MsiBackend.cs b/src/WixToolset.Core.WindowsInstaller/MsiBackend.cs
new file mode 100644
index 00000000..716ea000
--- /dev/null
+++ b/src/WixToolset.Core.WindowsInstaller/MsiBackend.cs
@@ -0,0 +1,36 @@
+// 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 WixToolset.Core.WindowsInstaller.Bind;
+    using WixToolset.Core.WindowsInstaller.Inscribe;
+    using WixToolset.Core.WindowsInstaller.Unbind;
+    using WixToolset.Data;
+    using WixToolset.Data.Bind;
+    using WixToolset.Extensibility;
+
+    internal class MsiBackend : IBackend
+    {
+        public BindResult Bind(IBindContext context)
+        {
+            var validator = Validator.CreateFromContext(context, "darice.cub");
+
+            var command = new BindDatabaseCommand(context, validator);
+            command.Execute();
+
+            return new BindResult(command.FileTransfers, command.ContentFilePaths);
+        }
+
+        public bool Inscribe(IInscribeContext context)
+        {
+            var command = new InscribeMsiPackageCommand(context);
+            return command.Execute();
+        }
+
+        public Output Unbind(IUnbindContext context)
+        {
+            var command = new UnbindMsiOrMsmCommand(context);
+            return command.Execute();
+        }
+    }
+}
diff --git a/src/WixToolset.Core.WindowsInstaller/MsmBackend.cs b/src/WixToolset.Core.WindowsInstaller/MsmBackend.cs
new file mode 100644
index 00000000..268213d7
--- /dev/null
+++ b/src/WixToolset.Core.WindowsInstaller/MsmBackend.cs
@@ -0,0 +1,34 @@
+// 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 WixToolset.Core.WindowsInstaller.Bind;
+    using WixToolset.Core.WindowsInstaller.Unbind;
+    using WixToolset.Data;
+    using WixToolset.Data.Bind;
+    using WixToolset.Extensibility;
+
+    internal class MsmBackend : IBackend
+    {
+        public BindResult Bind(IBindContext context)
+        {
+            var validator = Validator.CreateFromContext(context, "mergemod.cub");
+
+            var command = new BindDatabaseCommand(context, validator);
+            command.Execute();
+
+            return new BindResult(command.FileTransfers, command.ContentFilePaths);
+        }
+
+        public bool Inscribe(IInscribeContext context)
+        {
+            return false;
+        }
+
+        public Output Unbind(IUnbindContext context)
+        {
+            var command = new UnbindMsiOrMsmCommand(context);
+            return command.Execute();
+        }
+    }
+}
diff --git a/src/WixToolset.Core.WindowsInstaller/MspBackend.cs b/src/WixToolset.Core.WindowsInstaller/MspBackend.cs
new file mode 100644
index 00000000..4b13258b
--- /dev/null
+++ b/src/WixToolset.Core.WindowsInstaller/MspBackend.cs
@@ -0,0 +1,111 @@
+// 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.ComponentModel;
+    using System.IO;
+    using WixToolset.Core.Native;
+    using WixToolset.Core.WindowsInstaller.Unbind;
+    using WixToolset.Data;
+    using WixToolset.Data.Bind;
+    using WixToolset.Extensibility;
+    using WixToolset.Msi;
+    using WixToolset.Ole32;
+
+    internal class MspBackend : IBackend
+    {
+        public BindResult Bind(IBindContext context)
+        {
+            throw new NotImplementedException();
+        }
+
+        public bool Inscribe(IInscribeContext context)
+        {
+            throw new NotImplementedException();
+        }
+
+        public Output Unbind(IUnbindContext context)
+        {
+            Output patch;
+
+            // patch files are essentially database files (use a special flag to let the API know its a patch file)
+            try
+            {
+                using (Database database = new Database(context.InputFilePath, OpenDatabase.ReadOnly | OpenDatabase.OpenPatchFile))
+                {
+                    var unbindCommand = new UnbindDatabaseCommand(context.Messaging, database, context.InputFilePath, OutputType.Patch, context.ExportBasePath, context.IntermediateFolder, context.IsAdminImage, context.SuppressDemodularization, skipSummaryInfo: false);
+                    patch = unbindCommand.Execute();
+                }
+            }
+            catch (Win32Exception e)
+            {
+                if (0x6E == e.NativeErrorCode) // ERROR_OPEN_FAILED
+                {
+                    throw new WixException(WixErrors.OpenDatabaseFailed(context.InputFilePath));
+                }
+
+                throw;
+            }
+
+            // retrieve the transforms (they are in substorages)
+            using (Storage storage = Storage.Open(context.InputFilePath, StorageMode.Read | StorageMode.ShareDenyWrite))
+            {
+                Table summaryInformationTable = patch.Tables["_SummaryInformation"];
+                foreach (Row row in summaryInformationTable.Rows)
+                {
+                    if (8 == (int)row[0]) // PID_LASTAUTHOR
+                    {
+                        string value = (string)row[1];
+
+                        foreach (string decoratedSubStorageName in value.Split(';'))
+                        {
+                            string subStorageName = decoratedSubStorageName.Substring(1);
+                            string transformFile = Path.Combine(context.IntermediateFolder, String.Concat("Transform", Path.DirectorySeparatorChar, subStorageName, ".mst"));
+
+                            // ensure the parent directory exists
+                            System.IO.Directory.CreateDirectory(Path.GetDirectoryName(transformFile));
+
+                            // copy the substorage to a new storage for the transform file
+                            using (Storage subStorage = storage.OpenStorage(subStorageName))
+                            {
+                                using (Storage transformStorage = Storage.CreateDocFile(transformFile, StorageMode.ReadWrite | StorageMode.ShareExclusive | StorageMode.Create))
+                                {
+                                    subStorage.CopyTo(transformStorage);
+                                }
+                            }
+
+                            // unbind the transform
+                            var unbindCommand= new UnbindTransformCommand(context.Messaging, transformFile, (null == context.ExportBasePath ? null : Path.Combine(context.ExportBasePath, subStorageName)), context.IntermediateFolder);
+                            var transform = unbindCommand.Execute();
+
+                            patch.SubStorages.Add(new SubStorage(subStorageName, transform));
+                        }
+
+                        break;
+                    }
+                }
+            }
+
+            // extract the files from the cabinets
+            // TODO: use per-transform export paths for support of multi-product patches
+            if (null != context.ExportBasePath && !context.SuppressExtractCabinets)
+            {
+                using (Database database = new Database(context.InputFilePath, OpenDatabase.ReadOnly | OpenDatabase.OpenPatchFile))
+                {
+                    foreach (SubStorage subStorage in patch.SubStorages)
+                    {
+                        // only patch transforms should carry files
+                        if (subStorage.Name.StartsWith("#", StringComparison.Ordinal))
+                        {
+                            var extractCommand = new ExtractCabinetsCommand(subStorage.Data, database, context.InputFilePath, context.ExportBasePath, context.IntermediateFolder);
+                            extractCommand.Execute();
+                        }
+                    }
+                }
+            }
+
+            return patch;
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/WixToolset.Core.WindowsInstaller/MstBackend.cs b/src/WixToolset.Core.WindowsInstaller/MstBackend.cs
new file mode 100644
index 00000000..2cb7da89
--- /dev/null
+++ b/src/WixToolset.Core.WindowsInstaller/MstBackend.cs
@@ -0,0 +1,37 @@
+// 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 WixToolset.Core.WindowsInstaller.Databases;
+    using WixToolset.Core.WindowsInstaller.Unbind;
+    using WixToolset.Data;
+    using WixToolset.Data.Bind;
+    using WixToolset.Extensibility;
+
+    internal class MstBackend : IBackend
+    {
+        public BindResult Bind(IBindContext context)
+        {
+            var command = new BindTransformCommand();
+            command.Extensions = context.Extensions;
+            command.TempFilesLocation = context.IntermediateFolder;
+            command.Transform = context.IntermediateRepresentation;
+            command.OutputPath = context.OutputPath;
+            command.Execute();
+
+            return new BindResult(Array.Empty<FileTransfer>(), Array.Empty<string>());
+        }
+
+        public bool Inscribe(IInscribeContext context)
+        {
+            throw new NotImplementedException();
+        }
+
+        public Output Unbind(IUnbindContext context)
+        {
+            var command = new UnbindMsiOrMsmCommand(context);
+            return command.Execute();
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/WixToolset.Core/Ole32/Storage.cs b/src/WixToolset.Core.WindowsInstaller/Ole32/Storage.cs
index c6a43bc4..c6a43bc4 100644
--- a/src/WixToolset.Core/Ole32/Storage.cs
+++ b/src/WixToolset.Core.WindowsInstaller/Ole32/Storage.cs
diff --git a/src/WixToolset.Core/Patch.cs b/src/WixToolset.Core.WindowsInstaller/Patch.cs
index e3e6c27f..67150e32 100644
--- a/src/WixToolset.Core/Patch.cs
+++ b/src/WixToolset.Core.WindowsInstaller/Patch.cs
@@ -9,35 +9,8 @@ namespace WixToolset.Data
     using System.Globalization;
     using WixToolset.Data.Rows;
     using WixToolset.Extensibility;
-    using WixToolset.Msi;
     using WixToolset.Core.Native;
-
-    /// <summary>
-    /// Values for the OptimizeCA MsiPatchMetdata property, which indicates whether custom actions can be skipped when applying the patch.
-    /// </summary>
-    [Flags]
-    internal enum OptimizeCA
-    {
-        /// <summary>
-        /// No custom actions are skipped.
-        /// </summary>
-        None = 0,
-
-        /// <summary>
-        /// Skip property (type 51) and directory (type 35) assignment custom actions.
-        /// </summary>
-        SkipAssignment = 1,
-
-        /// <summary>
-        /// Skip immediate custom actions that are not property or directory assignment custom actions.
-        /// </summary>
-        SkipImmediate = 2,
-
-        /// <summary>
-        /// Skip custom actions that run within the script.
-        /// </summary>
-        SkipDeferred = 4,
-    }
+    using WixToolset.Msi;
 
     /// <summary>
     /// Contains output tables and logic for building an MSP package.
@@ -80,8 +53,6 @@ namespace WixToolset.Data
         [SuppressMessage("Microsoft.Globalization", "CA1303:DoNotPassLiteralsAsLocalizedParameters", MessageId = "System.InvalidOperationException.#ctor(System.String)")]
         public void AttachTransforms(List<PatchTransform> transforms)
         {
-            InspectorCore inspectorCore = new InspectorCore();
-
             // Track if at least one transform gets attached.
             bool attachedTransform = false;
 
@@ -429,16 +400,6 @@ namespace WixToolset.Data
             Row savedbyRow = patchSummaryInfo.CreateRow(null);
             savedbyRow[0] = (int)SummaryInformation.Patch.TransformNames;
             savedbyRow[1] = String.Join(";", (string[])transformNames.ToArray(typeof(string)));
-
-            // inspect the patch and filtered transforms
-            foreach (InspectorExtension inspectorExtension in this.inspectorExtensions)
-            {
-                inspectorExtension.Core = inspectorCore;
-                inspectorExtension.InspectOutput(this.patch);
-
-                // reset
-                inspectorExtension.Core = null;
-            }
         }
 
         /// <summary>
diff --git a/src/WixToolset.Core/PatchAPI/PatchInterop.cs b/src/WixToolset.Core.WindowsInstaller/PatchAPI/PatchInterop.cs
index ce749a33..fcd749d2 100644
--- a/src/WixToolset.Core/PatchAPI/PatchInterop.cs
+++ b/src/WixToolset.Core.WindowsInstaller/PatchAPI/PatchInterop.cs
@@ -7,6 +7,7 @@ namespace WixToolset.PatchAPI
     using System.Diagnostics.CodeAnalysis;
     using System.Globalization;
     using System.Runtime.InteropServices;
+    using WixToolset.Core;
 
     /// <summary>
     /// Interop class for the mspatchc.dll.
@@ -323,20 +324,6 @@ namespace WixToolset.PatchAPI
         internal const uint PATCH_OPTION_VALID_FLAGS       = 0xC0FF0007;
 
         //
-        // The following flags are used with PATCH_OPTION_DATA SymbolOptionFlags:
-        //
-
-        [Flags]
-        public enum PatchSymbolFlagsType :uint
-        {
-            PATCH_SYMBOL_NO_IMAGEHLP       = 0x00000001, // don't use imagehlp.dll
-            PATCH_SYMBOL_NO_FAILURES       = 0x00000002, // don't fail patch due to imagehlp failures
-            PATCH_SYMBOL_UNDECORATED_TOO   = 0x00000004, // after matching decorated symbols, try to match remaining by undecorated names
-            PATCH_SYMBOL_RESERVED1         = 0x80000000, // (used internally)
-            MaxValue = PATCH_SYMBOL_NO_IMAGEHLP | PATCH_SYMBOL_NO_FAILURES | PATCH_SYMBOL_UNDECORATED_TOO
-        }
-
-        //
         // The following flags are used with PATCH_OPTION_DATA ExtendedOptionFlags:
         //
 
diff --git a/src/WixToolset.Core.WindowsInstaller/Unbind/ExtractCabinetsCommand.cs b/src/WixToolset.Core.WindowsInstaller/Unbind/ExtractCabinetsCommand.cs
new file mode 100644
index 00000000..229e75b4
--- /dev/null
+++ b/src/WixToolset.Core.WindowsInstaller/Unbind/ExtractCabinetsCommand.cs
@@ -0,0 +1,146 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.Core.WindowsInstaller.Unbind
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Specialized;
+    using System.Globalization;
+    using System.IO;
+    using WixToolset.Core.Cab;
+    using WixToolset.Data;
+    using WixToolset.Data.Rows;
+    using WixToolset.Msi;
+
+    internal class ExtractCabinetsCommand
+    {
+        public ExtractCabinetsCommand(Output output, Database database, string inputFilePath, string exportBasePath, string intermediateFolder)
+        {
+            this.Output = output;
+            this.Database = database;
+            this.InputFilePath = inputFilePath;
+            this.ExportBasePath = exportBasePath;
+            this.IntermediateFolder = intermediateFolder;
+        }
+
+        private Output Output { get; }
+
+        private Database Database { get; }
+
+        private string InputFilePath { get; }
+
+        private string ExportBasePath { get; }
+
+        private string IntermediateFolder { get; }
+
+        public void Execute()
+        {
+            string databaseBasePath = Path.GetDirectoryName(this.InputFilePath);
+            StringCollection cabinetFiles = new StringCollection();
+            SortedList embeddedCabinets = new SortedList();
+
+            // index all of the cabinet files
+            if (OutputType.Module == this.Output.Type)
+            {
+                embeddedCabinets.Add(0, "MergeModule.CABinet");
+            }
+            else if (null != this.Output.Tables["Media"])
+            {
+                foreach (MediaRow mediaRow in this.Output.Tables["Media"].Rows)
+                {
+                    if (null != mediaRow.Cabinet)
+                    {
+                        if (OutputType.Product == this.Output.Type ||
+                            (OutputType.Transform == this.Output.Type && RowOperation.Add == mediaRow.Operation))
+                        {
+                            if (mediaRow.Cabinet.StartsWith("#", StringComparison.Ordinal))
+                            {
+                                embeddedCabinets.Add(mediaRow.DiskId, mediaRow.Cabinet.Substring(1));
+                            }
+                            else
+                            {
+                                cabinetFiles.Add(Path.Combine(databaseBasePath, mediaRow.Cabinet));
+                            }
+                        }
+                    }
+                }
+            }
+
+            // extract the embedded cabinet files from the database
+            if (0 < embeddedCabinets.Count)
+            {
+                using (View streamsView = this.Database.OpenView("SELECT `Data` FROM `_Streams` WHERE `Name` = ?"))
+                {
+                    foreach (int diskId in embeddedCabinets.Keys)
+                    {
+                        using (Record record = new Record(1))
+                        {
+                            record.SetString(1, (string)embeddedCabinets[diskId]);
+                            streamsView.Execute(record);
+                        }
+
+                        using (Record record = streamsView.Fetch())
+                        {
+                            if (null != record)
+                            {
+                                // since the cabinets are stored in case-sensitive streams inside the msi, but the file system is not case-sensitive,
+                                // embedded cabinets must be extracted to a canonical file name (like their diskid) to ensure extraction will always work
+                                string cabinetFile = Path.Combine(this.IntermediateFolder, String.Concat("Media", Path.DirectorySeparatorChar, diskId.ToString(CultureInfo.InvariantCulture), ".cab"));
+
+                                // ensure the parent directory exists
+                                System.IO.Directory.CreateDirectory(Path.GetDirectoryName(cabinetFile));
+
+                                using (FileStream fs = System.IO.File.Create(cabinetFile))
+                                {
+                                    int bytesRead;
+                                    byte[] buffer = new byte[512];
+
+                                    while (0 != (bytesRead = record.GetStream(1, buffer, buffer.Length)))
+                                    {
+                                        fs.Write(buffer, 0, bytesRead);
+                                    }
+                                }
+
+                                cabinetFiles.Add(cabinetFile);
+                            }
+                            else
+                            {
+                                // TODO: warning about missing embedded cabinet
+                            }
+                        }
+                    }
+                }
+            }
+
+            // extract the cabinet files
+            if (0 < cabinetFiles.Count)
+            {
+                string fileDirectory = Path.Combine(this.ExportBasePath, "File");
+
+                // delete the directory and its files to prevent cab extraction due to an existing file
+                if (Directory.Exists(fileDirectory))
+                {
+                    Directory.Delete(fileDirectory, true);
+                }
+
+                // ensure the directory exists or extraction will fail
+                Directory.CreateDirectory(fileDirectory);
+
+                foreach (string cabinetFile in cabinetFiles)
+                {
+                    using (var extractCab = new WixExtractCab())
+                    {
+                        try
+                        {
+                            extractCab.Extract(cabinetFile, fileDirectory);
+                        }
+                        catch (FileNotFoundException)
+                        {
+                            throw new WixException(WixErrors.FileNotFound(new SourceLineNumber(this.InputFilePath), cabinetFile));
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/src/WixToolset.Core.WindowsInstaller/Unbind/UnbindDatabaseCommand.cs b/src/WixToolset.Core.WindowsInstaller/Unbind/UnbindDatabaseCommand.cs
new file mode 100644
index 00000000..208be874
--- /dev/null
+++ b/src/WixToolset.Core.WindowsInstaller/Unbind/UnbindDatabaseCommand.cs
@@ -0,0 +1,791 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.Core.WindowsInstaller.Unbind
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.IO;
+    using System.Text.RegularExpressions;
+    using WixToolset.Core.Native;
+    using WixToolset.Data;
+    using WixToolset.Data.Rows;
+    using WixToolset.Msi;
+
+    internal class UnbindDatabaseCommand
+    {
+        public UnbindDatabaseCommand(Messaging messaging, Database database, string databasePath, OutputType outputType, string exportBasePath, string intermediateFolder, bool isAdminImage, bool suppressDemodularization, bool skipSummaryInfo)
+        {
+            this.Messaging = messaging;
+            this.Database = database;
+            this.DatabasePath = databasePath;
+            this.OutputType = outputType;
+            this.ExportBasePath = exportBasePath;
+            this.IntermediateFolder = intermediateFolder;
+            this.IsAdminImage = isAdminImage;
+            this.SuppressDemodularization = suppressDemodularization;
+            this.SkipSummaryInfo = skipSummaryInfo;
+
+            this.TableDefinitions = WindowsInstallerStandard.GetTableDefinitions();
+        }
+
+        public Messaging Messaging { get; }
+
+        public Database Database { get; }
+
+        public string DatabasePath { get; }
+
+        public OutputType OutputType { get; }
+
+        public string ExportBasePath { get; }
+
+        public string IntermediateFolder { get; }
+
+        public bool IsAdminImage { get; }
+
+        public bool SuppressDemodularization { get; }
+
+        public bool SkipSummaryInfo { get; }
+
+        public TableDefinitionCollection TableDefinitions { get; }
+
+        private int SectionCount { get; set; }
+
+        public Output Execute()
+        {
+            string modularizationGuid = null;
+            Output output = new Output(new SourceLineNumber(this.DatabasePath));
+            View validationView = null;
+
+            // set the output type
+            output.Type = this.OutputType;
+
+            // get the codepage
+            this.Database.Export("_ForceCodepage", this.IntermediateFolder, "_ForceCodepage.idt");
+            using (StreamReader sr = File.OpenText(Path.Combine(this.IntermediateFolder, "_ForceCodepage.idt")))
+            {
+                string line;
+
+                while (null != (line = sr.ReadLine()))
+                {
+                    string[] data = line.Split('\t');
+
+                    if (2 == data.Length)
+                    {
+                        output.Codepage = Convert.ToInt32(data[0], CultureInfo.InvariantCulture);
+                    }
+                }
+            }
+
+            // get the summary information table if it exists; it won't if unbinding a transform
+            if (!this.SkipSummaryInfo)
+            {
+                using (SummaryInformation summaryInformation = new SummaryInformation(this.Database))
+                {
+                    Table table = new Table(null, this.TableDefinitions["_SummaryInformation"]);
+
+                    for (int i = 1; 19 >= i; i++)
+                    {
+                        string value = summaryInformation.GetProperty(i);
+
+                        if (0 < value.Length)
+                        {
+                            Row row = table.CreateRow(output.SourceLineNumbers);
+                            row[0] = i;
+                            row[1] = value;
+                        }
+                    }
+
+                    output.Tables.Add(table);
+                }
+            }
+
+            try
+            {
+                // open a view on the validation table if it exists
+                if (this.Database.TableExists("_Validation"))
+                {
+                    validationView = this.Database.OpenView("SELECT * FROM `_Validation` WHERE `Table` = ? AND `Column` = ?");
+                }
+
+                // get the normal tables
+                using (View tablesView = this.Database.OpenExecuteView("SELECT * FROM _Tables"))
+                {
+                    while (true)
+                    {
+                        using (Record tableRecord = tablesView.Fetch())
+                        {
+                            if (null == tableRecord)
+                            {
+                                break;
+                            }
+
+                            string tableName = tableRecord.GetString(1);
+
+                            using (View tableView = this.Database.OpenExecuteView(String.Format(CultureInfo.InvariantCulture, "SELECT * FROM `{0}`", tableName)))
+                            {
+                                List<ColumnDefinition> columns;
+                                using (Record columnNameRecord = tableView.GetColumnInfo(MsiInterop.MSICOLINFONAMES),
+                                              columnTypeRecord = tableView.GetColumnInfo(MsiInterop.MSICOLINFOTYPES))
+                                {
+                                    // index the primary keys
+                                    HashSet<string> tablePrimaryKeys = new HashSet<string>();
+                                    using (Record primaryKeysRecord = this.Database.PrimaryKeys(tableName))
+                                    {
+                                        int primaryKeysFieldCount = primaryKeysRecord.GetFieldCount();
+
+                                        for (int i = 1; i <= primaryKeysFieldCount; i++)
+                                        {
+                                            tablePrimaryKeys.Add(primaryKeysRecord.GetString(i));
+                                        }
+                                    }
+
+                                    int columnCount = columnNameRecord.GetFieldCount();
+                                    columns = new List<ColumnDefinition>(columnCount);
+                                    for (int i = 1; i <= columnCount; i++)
+                                    {
+                                        string columnName = columnNameRecord.GetString(i);
+                                        string idtType = columnTypeRecord.GetString(i);
+
+                                        ColumnType columnType;
+                                        int length;
+                                        bool nullable;
+
+                                        ColumnCategory columnCategory = ColumnCategory.Unknown;
+                                        ColumnModularizeType columnModularizeType = ColumnModularizeType.None;
+                                        bool primary = tablePrimaryKeys.Contains(columnName);
+                                        bool minValueSet = false;
+                                        int minValue = -1;
+                                        bool maxValueSet = false;
+                                        int maxValue = -1;
+                                        string keyTable = null;
+                                        bool keyColumnSet = false;
+                                        int keyColumn = -1;
+                                        string category = null;
+                                        string set = null;
+                                        string description = null;
+
+                                        // get the column type, length, and whether its nullable
+                                        switch (Char.ToLower(idtType[0], CultureInfo.InvariantCulture))
+                                        {
+                                            case 'i':
+                                                columnType = ColumnType.Number;
+                                                break;
+                                            case 'l':
+                                                columnType = ColumnType.Localized;
+                                                break;
+                                            case 's':
+                                                columnType = ColumnType.String;
+                                                break;
+                                            case 'v':
+                                                columnType = ColumnType.Object;
+                                                break;
+                                            default:
+                                                // TODO: error
+                                                columnType = ColumnType.Unknown;
+                                                break;
+                                        }
+                                        length = Convert.ToInt32(idtType.Substring(1), CultureInfo.InvariantCulture);
+                                        nullable = Char.IsUpper(idtType[0]);
+
+                                        // try to get validation information
+                                        if (null != validationView)
+                                        {
+                                            using (Record validationRecord = new Record(2))
+                                            {
+                                                validationRecord.SetString(1, tableName);
+                                                validationRecord.SetString(2, columnName);
+
+                                                validationView.Execute(validationRecord);
+                                            }
+
+                                            using (Record validationRecord = validationView.Fetch())
+                                            {
+                                                if (null != validationRecord)
+                                                {
+                                                    string validationNullable = validationRecord.GetString(3);
+                                                    minValueSet = !validationRecord.IsNull(4);
+                                                    minValue = (minValueSet ? validationRecord.GetInteger(4) : -1);
+                                                    maxValueSet = !validationRecord.IsNull(5);
+                                                    maxValue = (maxValueSet ? validationRecord.GetInteger(5) : -1);
+                                                    keyTable = (!validationRecord.IsNull(6) ? validationRecord.GetString(6) : null);
+                                                    keyColumnSet = !validationRecord.IsNull(7);
+                                                    keyColumn = (keyColumnSet ? validationRecord.GetInteger(7) : -1);
+                                                    category = (!validationRecord.IsNull(8) ? validationRecord.GetString(8) : null);
+                                                    set = (!validationRecord.IsNull(9) ? validationRecord.GetString(9) : null);
+                                                    description = (!validationRecord.IsNull(10) ? validationRecord.GetString(10) : null);
+
+                                                    // check the validation nullable value against the column definition
+                                                    if (null == validationNullable)
+                                                    {
+                                                        // TODO: warn for illegal validation nullable column
+                                                    }
+                                                    else if ((nullable && "Y" != validationNullable) || (!nullable && "N" != validationNullable))
+                                                    {
+                                                        // TODO: warn for mismatch between column definition and validation nullable
+                                                    }
+
+                                                    // convert category to ColumnCategory
+                                                    if (null != category)
+                                                    {
+                                                        try
+                                                        {
+                                                            columnCategory = (ColumnCategory)Enum.Parse(typeof(ColumnCategory), category, true);
+                                                        }
+                                                        catch (ArgumentException)
+                                                        {
+                                                            columnCategory = ColumnCategory.Unknown;
+                                                        }
+                                                    }
+                                                }
+                                                else
+                                                {
+                                                    // TODO: warn about no validation information
+                                                }
+                                            }
+                                        }
+
+                                        // guess the modularization type
+                                        if ("Icon" == keyTable && 1 == keyColumn)
+                                        {
+                                            columnModularizeType = ColumnModularizeType.Icon;
+                                        }
+                                        else if ("Condition" == columnName)
+                                        {
+                                            columnModularizeType = ColumnModularizeType.Condition;
+                                        }
+                                        else if (ColumnCategory.Formatted == columnCategory || ColumnCategory.FormattedSDDLText == columnCategory)
+                                        {
+                                            columnModularizeType = ColumnModularizeType.Property;
+                                        }
+                                        else if (ColumnCategory.Identifier == columnCategory)
+                                        {
+                                            columnModularizeType = ColumnModularizeType.Column;
+                                        }
+
+                                        columns.Add(new ColumnDefinition(columnName, columnType, length, primary, nullable, columnModularizeType, (ColumnType.Localized == columnType), minValueSet, minValue, maxValueSet, maxValue, keyTable, keyColumnSet, keyColumn, columnCategory, set, description, true, true));
+                                    }
+                                }
+
+                                TableDefinition tableDefinition = new TableDefinition(tableName, columns, false, false);
+
+                                // use our table definitions if core properties are the same; this allows us to take advantage
+                                // of wix concepts like localizable columns which current code assumes
+                                if (this.TableDefinitions.Contains(tableName) && 0 == tableDefinition.CompareTo(this.TableDefinitions[tableName]))
+                                {
+                                    tableDefinition = this.TableDefinitions[tableName];
+                                }
+
+                                Table table = new Table(null, tableDefinition);
+
+                                while (true)
+                                {
+                                    using (Record rowRecord = tableView.Fetch())
+                                    {
+                                        if (null == rowRecord)
+                                        {
+                                            break;
+                                        }
+
+                                        int recordCount = rowRecord.GetFieldCount();
+                                        Row row = table.CreateRow(output.SourceLineNumbers);
+
+                                        for (int i = 0; recordCount > i && row.Fields.Length > i; i++)
+                                        {
+                                            if (rowRecord.IsNull(i + 1))
+                                            {
+                                                if (!row.Fields[i].Column.Nullable)
+                                                {
+                                                    // TODO: display an error for a null value in a non-nullable field OR
+                                                    // display a warning and put an empty string in the value to let the compiler handle it
+                                                    // (the second option is risky because the later code may make certain assumptions about
+                                                    // the contents of a row value)
+                                                }
+                                            }
+                                            else
+                                            {
+                                                switch (row.Fields[i].Column.Type)
+                                                {
+                                                    case ColumnType.Number:
+                                                        bool success = false;
+                                                        int intValue = rowRecord.GetInteger(i + 1);
+                                                        if (row.Fields[i].Column.IsLocalizable)
+                                                        {
+                                                            success = row.BestEffortSetField(i, Convert.ToString(intValue, CultureInfo.InvariantCulture));
+                                                        }
+                                                        else
+                                                        {
+                                                            success = row.BestEffortSetField(i, intValue);
+                                                        }
+
+                                                        if (!success)
+                                                        {
+                                                            this.Messaging.OnMessage(WixWarnings.BadColumnDataIgnored(row.SourceLineNumbers, Convert.ToString(intValue, CultureInfo.InvariantCulture), tableName, row.Fields[i].Column.Name));
+                                                        }
+                                                        break;
+                                                    case ColumnType.Object:
+                                                        string sourceFile = "FILE NOT EXPORTED, USE THE dark.exe -x OPTION TO EXPORT BINARIES";
+
+                                                        if (null != this.ExportBasePath)
+                                                        {
+                                                            string relativeSourceFile = Path.Combine(tableName, row.GetPrimaryKey('.'));
+                                                            sourceFile = Path.Combine(this.ExportBasePath, relativeSourceFile);
+
+                                                            // ensure the parent directory exists
+                                                            System.IO.Directory.CreateDirectory(Path.Combine(this.ExportBasePath, tableName));
+
+                                                            using (FileStream fs = System.IO.File.Create(sourceFile))
+                                                            {
+                                                                int bytesRead;
+                                                                byte[] buffer = new byte[512];
+
+                                                                while (0 != (bytesRead = rowRecord.GetStream(i + 1, buffer, buffer.Length)))
+                                                                {
+                                                                    fs.Write(buffer, 0, bytesRead);
+                                                                }
+                                                            }
+                                                        }
+
+                                                        row[i] = sourceFile;
+                                                        break;
+                                                    default:
+                                                        string value = rowRecord.GetString(i + 1);
+
+                                                        switch (row.Fields[i].Column.Category)
+                                                        {
+                                                            case ColumnCategory.Guid:
+                                                                value = value.ToUpper(CultureInfo.InvariantCulture);
+                                                                break;
+                                                        }
+
+                                                        // de-modularize
+                                                        if (!this.SuppressDemodularization && OutputType.Module == output.Type && ColumnModularizeType.None != row.Fields[i].Column.ModularizeType)
+                                                        {
+                                                            Regex modularization = new Regex(@"\.[0-9A-Fa-f]{8}_[0-9A-Fa-f]{4}_[0-9A-Fa-f]{4}_[0-9A-Fa-f]{4}_[0-9A-Fa-f]{12}");
+
+                                                            if (null == modularizationGuid)
+                                                            {
+                                                                Match match = modularization.Match(value);
+                                                                if (match.Success)
+                                                                {
+                                                                    modularizationGuid = String.Concat('{', match.Value.Substring(1).Replace('_', '-'), '}');
+                                                                }
+                                                            }
+
+                                                            value = modularization.Replace(value, String.Empty);
+                                                        }
+
+                                                        // escape "$(" for the preprocessor
+                                                        value = value.Replace("$(", "$$(");
+
+                                                        // escape things that look like wix variables
+                                                        MatchCollection matches = Common.WixVariableRegex.Matches(value);
+                                                        for (int j = matches.Count - 1; 0 <= j; j--)
+                                                        {
+                                                            value = value.Insert(matches[j].Index, "!");
+                                                        }
+
+                                                        row[i] = value;
+                                                        break;
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+
+                                output.Tables.Add(table);
+                            }
+
+                        }
+                    }
+                }
+            }
+            finally
+            {
+                if (null != validationView)
+                {
+                    validationView.Close();
+                }
+            }
+
+            // set the modularization guid as the PackageCode
+            if (null != modularizationGuid)
+            {
+                Table table = output.Tables["_SummaryInformation"];
+
+                foreach (Row row in table.Rows)
+                {
+                    if (9 == (int)row[0]) // PID_REVNUMBER
+                    {
+                        row[1] = modularizationGuid;
+                    }
+                }
+            }
+
+            if (this.IsAdminImage)
+            {
+                GenerateWixFileTable(this.DatabasePath, output);
+                GenerateSectionIds(output);
+            }
+
+            return output;
+        }
+
+        /// <summary>
+        /// Generates the WixFile table based on a path to an admin image msi and an Output.
+        /// </summary>
+        /// <param name="databaseFile">The path to the msi database file in an admin image.</param>
+        /// <param name="output">The Output that represents the msi database.</param>
+        private void GenerateWixFileTable(string databaseFile, Output output)
+        {
+            string adminRootPath = Path.GetDirectoryName(databaseFile);
+
+            Hashtable componentDirectoryIndex = new Hashtable();
+            Table componentTable = output.Tables["Component"];
+            foreach (Row row in componentTable.Rows)
+            {
+                componentDirectoryIndex.Add(row[0], row[2]);
+            }
+
+            // Index full source paths for all directories
+            Hashtable directoryDirectoryParentIndex = new Hashtable();
+            Hashtable directoryFullPathIndex = new Hashtable();
+            Hashtable directorySourceNameIndex = new Hashtable();
+            Table directoryTable = output.Tables["Directory"];
+            foreach (Row row in directoryTable.Rows)
+            {
+                directoryDirectoryParentIndex.Add(row[0], row[1]);
+                if (null == row[1])
+                {
+                    directoryFullPathIndex.Add(row[0], adminRootPath);
+                }
+                else
+                {
+                    directorySourceNameIndex.Add(row[0], GetAdminSourceName((string)row[2]));
+                }
+            }
+
+            foreach (DictionaryEntry directoryEntry in directoryDirectoryParentIndex)
+            {
+                if (!directoryFullPathIndex.ContainsKey(directoryEntry.Key))
+                {
+                    GetAdminFullPath((string)directoryEntry.Key, directoryDirectoryParentIndex, directorySourceNameIndex, directoryFullPathIndex);
+                }
+            }
+
+            Table fileTable = output.Tables["File"];
+            Table wixFileTable = output.EnsureTable(this.TableDefinitions["WixFile"]);
+            foreach (Row row in fileTable.Rows)
+            {
+                WixFileRow wixFileRow = new WixFileRow(null, this.TableDefinitions["WixFile"]);
+                wixFileRow.File = (string)row[0];
+                wixFileRow.Directory = (string)componentDirectoryIndex[(string)row[1]];
+                wixFileRow.Source = Path.Combine((string)directoryFullPathIndex[wixFileRow.Directory], GetAdminSourceName((string)row[2]));
+
+                if (!File.Exists(wixFileRow.Source))
+                {
+                    throw new WixException(WixErrors.WixFileNotFound(wixFileRow.Source));
+                }
+
+                wixFileTable.Rows.Add(wixFileRow);
+            }
+        }
+
+        /// <summary>
+        /// Gets the full path of a directory. Populates the full path index with the directory's full path and all of its parent directorie's full paths.
+        /// </summary>
+        /// <param name="directory">The directory identifier.</param>
+        /// <param name="directoryDirectoryParentIndex">The Hashtable containing all the directory to directory parent mapping.</param>
+        /// <param name="directorySourceNameIndex">The Hashtable containing all the directory to source name mapping.</param>
+        /// <param name="directoryFullPathIndex">The Hashtable containing a mapping between all of the directories and their previously calculated full paths.</param>
+        /// <returns>The full path to the directory.</returns>
+        private string GetAdminFullPath(string directory, Hashtable directoryDirectoryParentIndex, Hashtable directorySourceNameIndex, Hashtable directoryFullPathIndex)
+        {
+            string parent = (string)directoryDirectoryParentIndex[directory];
+            string sourceName = (string)directorySourceNameIndex[directory];
+
+            string parentFullPath;
+            if (directoryFullPathIndex.ContainsKey(parent))
+            {
+                parentFullPath = (string)directoryFullPathIndex[parent];
+            }
+            else
+            {
+                parentFullPath = GetAdminFullPath(parent, directoryDirectoryParentIndex, directorySourceNameIndex, directoryFullPathIndex);
+            }
+
+            if (null == sourceName)
+            {
+                sourceName = String.Empty;
+            }
+
+            string fullPath = Path.Combine(parentFullPath, sourceName);
+            directoryFullPathIndex.Add(directory, fullPath);
+
+            return fullPath;
+        }
+
+        /// <summary>
+        /// Get the source name in an admin image.
+        /// </summary>
+        /// <param name="value">The Filename value.</param>
+        /// <returns>The source name of the directory in an admin image.</returns>
+        private static string GetAdminSourceName(string value)
+        {
+            string name = null;
+            string[] names;
+            string shortname = null;
+            string shortsourcename = null;
+            string sourcename = null;
+
+            names = Common.GetNames(value);
+
+            if (null != names[0] && "." != names[0])
+            {
+                if (null != names[1])
+                {
+                    shortname = names[0];
+                }
+                else
+                {
+                    name = names[0];
+                }
+            }
+
+            if (null != names[1])
+            {
+                name = names[1];
+            }
+
+            if (null != names[2])
+            {
+                if (null != names[3])
+                {
+                    shortsourcename = names[2];
+                }
+                else
+                {
+                    sourcename = names[2];
+                }
+            }
+
+            if (null != names[3])
+            {
+                sourcename = names[3];
+            }
+
+            if (null != sourcename)
+            {
+                return sourcename;
+            }
+            else if (null != shortsourcename)
+            {
+                return shortsourcename;
+            }
+            else if (null != name)
+            {
+                return name;
+            }
+            else
+            {
+                return shortname;
+            }
+        }
+
+        /// <summary>
+        /// Creates section ids on rows which form logical groupings of resources.
+        /// </summary>
+        /// <param name="output">The Output that represents the msi database.</param>
+        private void GenerateSectionIds(Output output)
+        {
+            // First assign and index section ids for the tables that are in their own sections.
+            AssignSectionIdsToTable(output.Tables["Binary"], 0);
+            Hashtable componentSectionIdIndex = AssignSectionIdsToTable(output.Tables["Component"], 0);
+            Hashtable customActionSectionIdIndex = AssignSectionIdsToTable(output.Tables["CustomAction"], 0);
+            AssignSectionIdsToTable(output.Tables["Directory"], 0);
+            Hashtable featureSectionIdIndex = AssignSectionIdsToTable(output.Tables["Feature"], 0);
+            AssignSectionIdsToTable(output.Tables["Icon"], 0);
+            Hashtable digitalCertificateSectionIdIndex = AssignSectionIdsToTable(output.Tables["MsiDigitalCertificate"], 0);
+            AssignSectionIdsToTable(output.Tables["Property"], 0);
+
+            // Now handle all the tables that rely on the first set of indexes but also produce their own indexes. Order matters here.
+            Hashtable fileSectionIdIndex = ConnectTableToSectionAndIndex(output.Tables["File"], componentSectionIdIndex, 1, 0);
+            Hashtable appIdSectionIdIndex = ConnectTableToSectionAndIndex(output.Tables["Class"], componentSectionIdIndex, 2, 5);
+            Hashtable odbcDataSourceSectionIdIndex = ConnectTableToSectionAndIndex(output.Tables["ODBCDataSource"], componentSectionIdIndex, 1, 0);
+            Hashtable odbcDriverSectionIdIndex = ConnectTableToSectionAndIndex(output.Tables["ODBCDriver"], componentSectionIdIndex, 1, 0);
+            Hashtable registrySectionIdIndex = ConnectTableToSectionAndIndex(output.Tables["Registry"], componentSectionIdIndex, 5, 0);
+            Hashtable serviceInstallSectionIdIndex = ConnectTableToSectionAndIndex(output.Tables["ServiceInstall"], componentSectionIdIndex, 11, 0);
+
+            // Now handle all the tables which only rely on previous indexes and order does not matter.
+            foreach (Table table in output.Tables)
+            {
+                switch (table.Name)
+                {
+                    case "WixFile":
+                    case "MsiFileHash":
+                        ConnectTableToSection(table, fileSectionIdIndex, 0);
+                        break;
+                    case "MsiAssembly":
+                    case "MsiAssemblyName":
+                        ConnectTableToSection(table, componentSectionIdIndex, 0);
+                        break;
+                    case "MsiPackageCertificate":
+                    case "MsiPatchCertificate":
+                        ConnectTableToSection(table, digitalCertificateSectionIdIndex, 1);
+                        break;
+                    case "CreateFolder":
+                    case "FeatureComponents":
+                    case "MoveFile":
+                    case "ReserveCost":
+                    case "ODBCTranslator":
+                        ConnectTableToSection(table, componentSectionIdIndex, 1);
+                        break;
+                    case "TypeLib":
+                        ConnectTableToSection(table, componentSectionIdIndex, 2);
+                        break;
+                    case "Shortcut":
+                    case "Environment":
+                        ConnectTableToSection(table, componentSectionIdIndex, 3);
+                        break;
+                    case "RemoveRegistry":
+                        ConnectTableToSection(table, componentSectionIdIndex, 4);
+                        break;
+                    case "ServiceControl":
+                        ConnectTableToSection(table, componentSectionIdIndex, 5);
+                        break;
+                    case "IniFile":
+                    case "RemoveIniFile":
+                        ConnectTableToSection(table, componentSectionIdIndex, 7);
+                        break;
+                    case "AppId":
+                        ConnectTableToSection(table, appIdSectionIdIndex, 0);
+                        break;
+                    case "Condition":
+                        ConnectTableToSection(table, featureSectionIdIndex, 0);
+                        break;
+                    case "ODBCSourceAttribute":
+                        ConnectTableToSection(table, odbcDataSourceSectionIdIndex, 0);
+                        break;
+                    case "ODBCAttribute":
+                        ConnectTableToSection(table, odbcDriverSectionIdIndex, 0);
+                        break;
+                    case "AdminExecuteSequence":
+                    case "AdminUISequence":
+                    case "AdvtExecuteSequence":
+                    case "AdvtUISequence":
+                    case "InstallExecuteSequence":
+                    case "InstallUISequence":
+                        ConnectTableToSection(table, customActionSectionIdIndex, 0);
+                        break;
+                    case "LockPermissions":
+                    case "MsiLockPermissions":
+                        foreach (Row row in table.Rows)
+                        {
+                            string lockObject = (string)row[0];
+                            string tableName = (string)row[1];
+                            switch (tableName)
+                            {
+                                case "File":
+                                    row.SectionId = (string)fileSectionIdIndex[lockObject];
+                                    break;
+                                case "Registry":
+                                    row.SectionId = (string)registrySectionIdIndex[lockObject];
+                                    break;
+                                case "ServiceInstall":
+                                    row.SectionId = (string)serviceInstallSectionIdIndex[lockObject];
+                                    break;
+                            }
+                        }
+                        break;
+                }
+            }
+
+            // Now pass the output to each unbinder extension to allow them to analyze the output and determine thier proper section ids.
+            //foreach (IUnbinderExtension extension in this.unbinderExtensions)
+            //{
+            //    extension.GenerateSectionIds(output);
+            //}
+        }
+
+        /// <summary>
+        /// Creates new section ids on all the rows in a table.
+        /// </summary>
+        /// <param name="table">The table to add sections to.</param>
+        /// <param name="rowPrimaryKeyIndex">The index of the column which is used by other tables to reference this table.</param>
+        /// <returns>A Hashtable containing the tables key for each row paired with its assigned section id.</returns>
+        private Hashtable AssignSectionIdsToTable(Table table, int rowPrimaryKeyIndex)
+        {
+            Hashtable hashtable = new Hashtable();
+            if (null != table)
+            {
+                foreach (Row row in table.Rows)
+                {
+                    row.SectionId = GetNewSectionId();
+                    hashtable.Add(row[rowPrimaryKeyIndex], row.SectionId);
+                }
+            }
+            return hashtable;
+        }
+
+        /// <summary>
+        /// Connects a table's rows to an already sectioned table.
+        /// </summary>
+        /// <param name="table">The table containing rows that need to be connected to sections.</param>
+        /// <param name="sectionIdIndex">A hashtable containing keys to map table to its section.</param>
+        /// <param name="rowIndex">The index of the column which is used as the foreign key in to the sectionIdIndex.</param>
+        private static void ConnectTableToSection(Table table, Hashtable sectionIdIndex, int rowIndex)
+        {
+            if (null != table)
+            {
+                foreach (Row row in table.Rows)
+                {
+                    if (sectionIdIndex.ContainsKey(row[rowIndex]))
+                    {
+                        row.SectionId = (string)sectionIdIndex[row[rowIndex]];
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Connects a table's rows to an already sectioned table and produces an index for other tables to connect to it.
+        /// </summary>
+        /// <param name="table">The table containing rows that need to be connected to sections.</param>
+        /// <param name="sectionIdIndex">A hashtable containing keys to map table to its section.</param>
+        /// <param name="rowIndex">The index of the column which is used as the foreign key in to the sectionIdIndex.</param>
+        /// <param name="rowPrimaryKeyIndex">The index of the column which is used by other tables to reference this table.</param>
+        /// <returns>A Hashtable containing the tables key for each row paired with its assigned section id.</returns>
+        private static Hashtable ConnectTableToSectionAndIndex(Table table, Hashtable sectionIdIndex, int rowIndex, int rowPrimaryKeyIndex)
+        {
+            Hashtable newHashTable = new Hashtable();
+            if (null != table)
+            {
+                foreach (Row row in table.Rows)
+                {
+                    if (!sectionIdIndex.ContainsKey(row[rowIndex]))
+                    {
+                        continue;
+                    }
+
+                    row.SectionId = (string)sectionIdIndex[row[rowIndex]];
+                    if (null != row[rowPrimaryKeyIndex])
+                    {
+                        newHashTable.Add(row[rowPrimaryKeyIndex], row.SectionId);
+                    }
+                }
+            }
+            return newHashTable;
+        }
+
+        /// <summary>
+        /// Creates a new section identifier to be used when adding a section to an output.
+        /// </summary>
+        /// <returns>A string representing a new section id.</returns>
+        private string GetNewSectionId()
+        {
+            this.SectionCount++;
+            return "wix.section." + this.SectionCount.ToString(CultureInfo.InvariantCulture);
+        }
+    }
+}
diff --git a/src/WixToolset.Core.WindowsInstaller/Unbind/UnbindMsiOrMsmCommand.cs b/src/WixToolset.Core.WindowsInstaller/Unbind/UnbindMsiOrMsmCommand.cs
new file mode 100644
index 00000000..f04dcefe
--- /dev/null
+++ b/src/WixToolset.Core.WindowsInstaller/Unbind/UnbindMsiOrMsmCommand.cs
@@ -0,0 +1,53 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.Core.WindowsInstaller.Unbind
+{
+    using System;
+    using System.ComponentModel;
+    using WixToolset.Core.Native;
+    using WixToolset.Data;
+    using WixToolset.Extensibility;
+    using WixToolset.Msi;
+
+    internal class UnbindMsiOrMsmCommand
+    {
+        public UnbindMsiOrMsmCommand(IUnbindContext context)
+        {
+            this.Context = context;
+        }
+
+        public IUnbindContext Context { get; }
+
+        public Output Execute()
+        {
+            Output output;
+
+            try
+            {
+                using (Database database = new Database(this.Context.InputFilePath, OpenDatabase.ReadOnly))
+                {
+                    var unbindCommand = new UnbindDatabaseCommand(this.Context.Messaging, database, this.Context.InputFilePath, OutputType.Product, this.Context.ExportBasePath, this.Context.IntermediateFolder, this.Context.IsAdminImage, this.Context.SuppressDemodularization, skipSummaryInfo: false);
+                    output = unbindCommand.Execute();
+
+                    // extract the files from the cabinets
+                    if (!String.IsNullOrEmpty(this.Context.ExportBasePath) && !this.Context.SuppressExtractCabinets)
+                    {
+                        var extractCommand = new ExtractCabinetsCommand(output, database, this.Context.InputFilePath, this.Context.ExportBasePath, this.Context.IntermediateFolder);
+                        extractCommand.Execute();
+                    }
+                }
+            }
+            catch (Win32Exception e)
+            {
+                if (0x6E == e.NativeErrorCode) // ERROR_OPEN_FAILED
+                {
+                    throw new WixException(WixErrors.OpenDatabaseFailed(this.Context.InputFilePath));
+                }
+
+                throw;
+            }
+
+            return output;
+        }
+    }
+}
diff --git a/src/WixToolset.Core.WindowsInstaller/Unbind/UnbindTranformCommand.cs b/src/WixToolset.Core.WindowsInstaller/Unbind/UnbindTranformCommand.cs
new file mode 100644
index 00000000..c0eda9c7
--- /dev/null
+++ b/src/WixToolset.Core.WindowsInstaller/Unbind/UnbindTranformCommand.cs
@@ -0,0 +1,317 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.Core.WindowsInstaller.Unbind
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.ComponentModel;
+    using System.Globalization;
+    using System.IO;
+    using System.Linq;
+    using System.Text.RegularExpressions;
+    using WixToolset.Core.Native;
+    using WixToolset.Core.WindowsInstaller.Databases;
+    using WixToolset.Data;
+    using WixToolset.Data.Rows;
+    using WixToolset.Extensibility;
+    using WixToolset.Msi;
+
+    internal class UnbindTransformCommand
+    {
+        public UnbindTransformCommand(Messaging messaging, string transformFile, string exportBasePath, string intermediateFolder)
+        {
+            this.Messaging = messaging;
+            this.TransformFile = transformFile;
+            this.ExportBasePath = exportBasePath;
+            this.IntermediateFolder = intermediateFolder;
+
+            this.TableDefinitions = WindowsInstallerStandard.GetTableDefinitions();
+        }
+
+        private Messaging Messaging { get; }
+
+        private string TransformFile { get; }
+
+        private string ExportBasePath { get; }
+
+        private string IntermediateFolder { get; }
+
+        private TableDefinitionCollection TableDefinitions { get; }
+
+        private string EmptyFile { get; set; }
+        
+        public Output Execute()
+        {
+            Output transform = new Output(new SourceLineNumber(this.TransformFile));
+            transform.Type = OutputType.Transform;
+
+            // get the summary information table
+            using (SummaryInformation summaryInformation = new SummaryInformation(this.TransformFile))
+            {
+                Table table = transform.EnsureTable(this.TableDefinitions["_SummaryInformation"]);
+
+                for (int i = 1; 19 >= i; i++)
+                {
+                    string value = summaryInformation.GetProperty(i);
+
+                    if (0 < value.Length)
+                    {
+                        Row row = table.CreateRow(transform.SourceLineNumbers);
+                        row[0] = i;
+                        row[1] = value;
+                    }
+                }
+            }
+
+            // create a schema msi which hopefully matches the table schemas in the transform
+            Output schemaOutput = new Output(null);
+            string msiDatabaseFile = Path.Combine(this.IntermediateFolder, "schema.msi");
+            foreach (TableDefinition tableDefinition in this.TableDefinitions)
+            {
+                // skip unreal tables and the Patch table
+                if (!tableDefinition.Unreal && "Patch" != tableDefinition.Name)
+                {
+                    schemaOutput.EnsureTable(tableDefinition);
+                }
+            }
+
+            Hashtable addedRows = new Hashtable();
+            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))
+            {
+                // 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);
+                Output 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)
+                {
+                    string tableName = (string)row[0];
+                    string columnName = (string)row[1];
+                    string primaryKeys = (string)row[2];
+
+                    if ("INSERT" == columnName)
+                    {
+                        string 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);
+
+                        modifiedRows[index] = row;
+                    }
+                }
+
+                // 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];
+
+                    string index = String.Concat(tableName, ':', primaryKeys);
+
+                    // ignore information for added rows
+                    if (!addedRows.Contains(index))
+                    {
+                        Table table = schemaOutput.Tables[tableName];
+                        this.CreateRow(table, primaryKeys, true);
+                    }
+                }
+            }
+
+            // Re-bind the schema output with the placeholder rows.
+            this.GenerateDatabase(schemaOutput, msiDatabaseFile);
+
+            // apply the transform to the database and retrieve the modifications
+            using (Database msiDatabase = new Database(msiDatabaseFile, OpenDatabase.Transact))
+            {
+                try
+                {
+                    // apply the transform
+                    msiDatabase.ApplyTransform(this.TransformFile, TransformErrorConditions.All);
+
+                    // commit the database to guard against weird errors with streams
+                    msiDatabase.Commit();
+                }
+                catch (Win32Exception ex)
+                {
+                    if (0x65B == ex.NativeErrorCode)
+                    {
+                        // this commonly happens when the transform was built
+                        // against a database schema different from the internal
+                        // table definitions
+                        throw new WixException(WixErrors.TransformSchemaMismatch());
+                    }
+                }
+
+                // unbind the database
+                var unbindCommand = new UnbindDatabaseCommand(this.Messaging, msiDatabase, msiDatabaseFile, OutputType.Product, this.ExportBasePath, this.IntermediateFolder, false, false, skipSummaryInfo: true);
+                Output output = unbindCommand.Execute();
+
+                // index all the rows to easily find modified rows
+                Hashtable rows = new Hashtable();
+                foreach (Table table in output.Tables)
+                {
+                    foreach (Row 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)
+                {
+                    string tableName = (string)row[0];
+                    string columnName = (string)row[1];
+                    string primaryKeys = (string)row[2];
+
+                    Table table = transform.EnsureTable(this.TableDefinitions[tableName]);
+
+                    if ("CREATE" == columnName) // added table
+                    {
+                        table.Operation = TableOperation.Add;
+                    }
+                    else if ("DELETE" == columnName) // deleted row
+                    {
+                        Row deletedRow = this.CreateRow(table, primaryKeys, false);
+                        deletedRow.Operation = RowOperation.Delete;
+                    }
+                    else if ("DROP" == columnName) // dropped table
+                    {
+                        table.Operation = TableOperation.Drop;
+                    }
+                    else if ("INSERT" == columnName) // added row
+                    {
+                        string index = String.Concat(tableName, ':', primaryKeys);
+                        Row addedRow = (Row)rows[index];
+                        addedRow.Operation = RowOperation.Add;
+                        table.Rows.Add(addedRow);
+                    }
+                    else if (null != primaryKeys) // modified row
+                    {
+                        string 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))
+                        {
+                            Row modifiedRow = (Row)rows[index];
+
+                            // mark the field as modified
+                            int indexOfModifiedValue = -1;
+                            for (int i = 0; i < modifiedRow.TableDefinition.Columns.Count; ++i)
+                            {
+                                if (columnName.Equals(modifiedRow.TableDefinition.Columns[i].Name, StringComparison.Ordinal))
+                                {
+                                    indexOfModifiedValue = i;
+                                    break;
+                                }
+                            }
+                            modifiedRow.Fields[indexOfModifiedValue].Modified = true;
+
+                            // move the modified row into the transform the first time its encountered
+                            if (RowOperation.None == modifiedRow.Operation)
+                            {
+                                modifiedRow.Operation = RowOperation.Modify;
+                                table.Rows.Add(modifiedRow);
+                            }
+                        }
+                    }
+                    else // added column
+                    {
+                        ColumnDefinition column = table.Definition.Columns.Single(c => c.Name.Equals(columnName, StringComparison.Ordinal));
+                        column.Added = true;
+                    }
+                }
+            }
+
+            return transform;
+        }
+
+        private void GenerateDatabase(Output output, string databaseFile)
+        {
+            var command = new GenerateDatabaseCommand();
+            command.Extensions = Array.Empty<IBinderExtension>();
+            command.Output = output;
+            command.OutputPath = databaseFile;
+            command.KeepAddedColumns = true;
+            command.UseSubDirectory = false;
+            command.SuppressAddingValidationRows = true;
+            command.TableDefinitions = this.TableDefinitions;
+            command.TempFilesLocation = this.IntermediateFolder;
+            command.Codepage = -1;
+            command.Execute();
+        }
+
+        /// <summary>
+        /// Create a deleted or modified row.
+        /// </summary>
+        /// <param name="table">The table containing the row.</param>
+        /// <param name="primaryKeys">The primary keys of the row.</param>
+        /// <param name="setRequiredFields">Option to set all required fields with placeholder values.</param>
+        /// <returns>The new row.</returns>
+        private Row CreateRow(Table table, string primaryKeys, bool setRequiredFields)
+        {
+            Row row = table.CreateRow(null);
+
+            string[] primaryKeyParts = primaryKeys.Split('\t');
+            int primaryKeyPartIndex = 0;
+
+            for (int i = 0; i < table.Definition.Columns.Count; i++)
+            {
+                ColumnDefinition columnDefinition = table.Definition.Columns[i];
+
+                if (columnDefinition.PrimaryKey)
+                {
+                    if (ColumnType.Number == columnDefinition.Type && !columnDefinition.IsLocalizable)
+                    {
+                        row[i] = Convert.ToInt32(primaryKeyParts[primaryKeyPartIndex++], CultureInfo.InvariantCulture);
+                    }
+                    else
+                    {
+                        row[i] = primaryKeyParts[primaryKeyPartIndex++];
+                    }
+                }
+                else if (setRequiredFields)
+                {
+                    if (ColumnType.Number == columnDefinition.Type && !columnDefinition.IsLocalizable)
+                    {
+                        row[i] = 1;
+                    }
+                    else if (ColumnType.Object == columnDefinition.Type)
+                    {
+                        if (null == this.EmptyFile)
+                        {
+                            this.EmptyFile = Path.GetTempFileName() + ".empty";
+                            using (FileStream fileStream = File.Create(this.EmptyFile))
+                            {
+                            }
+                        }
+
+                        row[i] = this.EmptyFile;
+                    }
+                    else
+                    {
+                        row[i] = "1";
+                    }
+                }
+            }
+
+            return row;
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Validator.cs b/src/WixToolset.Core.WindowsInstaller/Validator.cs
index 6420b9b7..db66f600 100644
--- a/src/WixToolset.Core/Validator.cs
+++ b/src/WixToolset.Core.WindowsInstaller/Validator.cs
@@ -1,6 +1,6 @@
 // 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
+namespace WixToolset.Core.WindowsInstaller
 {
     using System;
     using System.Collections.Generic;
@@ -12,8 +12,10 @@ namespace WixToolset
     using System.Threading;
     using WixToolset.Data;
     using WixToolset.Extensibility;
-    using WixToolset.Msi;
     using WixToolset.Core.Native;
+    using WixToolset.Msi;
+    using System.Linq;
+    using System.Reflection;
 
     /// <summary>
     /// Runs internal consistency evaluators (ICEs) from cub files against a database.
@@ -23,9 +25,7 @@ namespace WixToolset
         private string actionName;
         private StringCollection cubeFiles;
         private ValidatorExtension extension;
-        private string[] ices;
         private Output output;
-        private string[] suppressedICEs;
         private InstallUIHandler validationUIHandler;
         private bool validationSessionComplete;
 
@@ -54,11 +54,7 @@ namespace WixToolset
         /// </summary>
         /// <value>The list of ICEs.</value>
         [SuppressMessage("Microsoft.Performance", "CA1819:PropertiesShouldNotReturnArrays")]
-        public string[] ICEs
-        {
-            get { return this.ices; }
-            set { this.ices = value; }
-        }
+        public ISet<string> ICEs { get; set; }
 
         /// <summary>
         /// Gets or sets the output used for finding source line information.
@@ -76,16 +72,12 @@ namespace WixToolset
         /// </summary>
         /// <value>The suppressed ICEs.</value>
         [SuppressMessage("Microsoft.Performance", "CA1819:PropertiesShouldNotReturnArrays")]
-        public string[] SuppressedICEs
-        {
-            get { return this.suppressedICEs; }
-            set { this.suppressedICEs = value; }
-        }
+        public ISet<string> SuppressedICEs { get; set; }
 
         /// <summary>
         /// Sets the temporary path for the Binder.
         /// </summary>
-        public string TempFilesLocation { private get; set; }
+        public string IntermediateFolder { private get; set; }
 
         /// <summary>
         /// Add a cube file to the validation run.
@@ -103,8 +95,6 @@ namespace WixToolset
         /// <returns>true if validation succeeded; false otherwise.</returns>
         public void Validate(string databaseFile)
         {
-            Dictionary<string, string> indexedICEs = new Dictionary<string, string>();
-            Dictionary<string, string> indexedSuppressedICEs = new Dictionary<string, string>();
             int previousUILevel = (int)InstallUILevels.Basic;
             IntPtr previousHwnd = IntPtr.Zero;
             InstallUIHandler previousUIHandler = null;
@@ -120,28 +110,10 @@ namespace WixToolset
             this.extension.InitializeValidator();
 
             // Ensure the temporary files can be created.
-            Directory.CreateDirectory(this.TempFilesLocation);
-
-            // index the ICEs
-            if (null != this.ices)
-            {
-                foreach (string ice in this.ices)
-                {
-                    indexedICEs[ice] = null;
-                }
-            }
-
-            // index the suppressed ICEs
-            if (null != this.suppressedICEs)
-            {
-                foreach (string suppressedICE in this.suppressedICEs)
-                {
-                    indexedSuppressedICEs[suppressedICE] = null;
-                }
-            }
+            Directory.CreateDirectory(this.IntermediateFolder);
 
             // copy the database to a temporary location so it can be manipulated
-            string tempDatabaseFile = Path.Combine(this.TempFilesLocation, Path.GetFileName(databaseFile));
+            string tempDatabaseFile = Path.Combine(this.IntermediateFolder, Path.GetFileName(databaseFile));
             File.Copy(databaseFile, tempDatabaseFile);
 
             // remove the read-only property from the temporary database
@@ -236,7 +208,7 @@ namespace WixToolset
 
                                 string action = record.GetString(1);
 
-                                if (!indexedSuppressedICEs.ContainsKey(action))
+                                if ((this.SuppressedICEs == null || !this.SuppressedICEs.Contains(action)) && (this.ICEs == null || this.ICEs.Contains(action)))
                                 {
                                     actions.Add(action);
                                 }
@@ -244,18 +216,6 @@ namespace WixToolset
                         }
                     }
 
-                    if (0 != indexedICEs.Count)
-                    {
-                        // Walk backwards and remove those that arent in the list
-                        for (int i = actions.Count - 1; 0 <= i; i--)
-                        {
-                            if (!indexedICEs.ContainsKey(actions[i]))
-                            {
-                                actions.RemoveAt(i);
-                            }
-                        }
-                    }
-
                     // disable the internal UI handler and set an external UI handler
                     previousUILevel = Installer.SetInternalUI((int)InstallUILevels.None, ref previousHwnd);
                     previousUIHandler = Installer.SetExternalUI(this.validationUIHandler, (int)InstallLogModes.Error | (int)InstallLogModes.Warning | (int)InstallLogModes.User, IntPtr.Zero);
@@ -370,6 +330,30 @@ namespace WixToolset
             this.extension.OnMessage(e);
         }
 
+        public static Validator CreateFromContext(IBindContext context, string cubeFilename)
+        {
+            Validator validator = null;
+
+            // Tell the binder about the validator if validation isn't suppressed
+            if (!context.SuppressValidation)
+            {
+                validator = new Validator();
+                validator.IntermediateFolder = Path.Combine(context.IntermediateFolder, "validate");
+
+                // set the default cube file
+                string thisPath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
+                validator.AddCubeFile(Path.Combine(thisPath, cubeFilename));
+
+                // Set the ICEs
+                validator.ICEs = new SortedSet<string>(context.Ices);
+
+                // Set the suppressed ICEs and disable ICEs that have equivalent-or-better checks in WiX.
+                validator.SuppressedICEs = new SortedSet<string>(context.SuppressIces.Union(new[] { "ICE08", "ICE33", "ICE47", "ICE66" }));
+            }
+
+            return validator;
+        }
+
         /// <summary>
         /// The validation external UI handler.
         /// </summary>
diff --git a/src/WixToolset.Core/Extensibility/ValidatorExtension.cs b/src/WixToolset.Core.WindowsInstaller/ValidatorExtension.cs
index 44ec3106..44ec3106 100644
--- a/src/WixToolset.Core/Extensibility/ValidatorExtension.cs
+++ b/src/WixToolset.Core.WindowsInstaller/ValidatorExtension.cs
diff --git a/src/WixToolset.Core.WindowsInstaller/WindowsInstallerBackendFactory.cs b/src/WixToolset.Core.WindowsInstaller/WindowsInstallerBackendFactory.cs
new file mode 100644
index 00000000..b66a4617
--- /dev/null
+++ b/src/WixToolset.Core.WindowsInstaller/WindowsInstallerBackendFactory.cs
@@ -0,0 +1,50 @@
+// 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;
+
+    internal class WindowsInstallerBackendFactory : IBackendFactory
+    {
+        public bool TryCreateBackend(string outputType, string outputFile, IBindContext context, out IBackend backend)
+        {
+            if (String.IsNullOrEmpty(outputType))
+            {
+                outputType = Path.GetExtension(outputFile);
+            }
+
+            switch (outputType.ToLowerInvariant())
+            {
+                case "module":
+                case ".msm":
+                    backend = new MsmBackend();
+                    return true;
+
+                case "msipackage":
+                case "product":
+                case ".msi":
+                    backend = new MsiBackend();
+                    return true;
+
+                case "patch":
+                case ".msp":
+                    backend = new MspBackend();
+                    return true;
+
+                //case "patchcreation":
+                //case ".pcp":
+                //    return new PatchCreationBackend();
+
+                case "transform":
+                case ".mst":
+                    backend = new MstBackend();
+                    return true;
+            }
+
+            backend = null;
+            return false;
+        }
+    }
+}
diff --git a/src/WixToolset.Core.WindowsInstaller/WixToolset.Core.WindowsInstaller.csproj b/src/WixToolset.Core.WindowsInstaller/WixToolset.Core.WindowsInstaller.csproj
new file mode 100644
index 00000000..d74cb1e8
--- /dev/null
+++ b/src/WixToolset.Core.WindowsInstaller/WixToolset.Core.WindowsInstaller.csproj
@@ -0,0 +1,36 @@
+<?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">
+  <PropertyGroup>
+    <TargetFramework>netstandard2.0</TargetFramework>
+    <Description>Core Windows Installer</Description>
+    <Title>WiX Toolset Core Windows Installer</Title>
+  </PropertyGroup>
+
+  <PropertyGroup>
+    <NoWarn>NU1701</NoWarn>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="$(WixToolsetRootFolder)\Data\src\WixToolset.Data\WixToolset.Data.csproj" Condition=" '$(Configuration)' == 'Debug' And Exists('$(WixToolsetRootFolder)\Data\src\WixToolset.Data\WixToolset.Data.csproj') " />
+    <PackageReference Include="WixToolset.Data" Version="4.0.*" Condition=" '$(Configuration)' == 'Release' Or !Exists('$(WixToolsetRootFolder)\Data\src\WixToolset.Data\WixToolset.Data.csproj') " />
+
+    <ProjectReference Include="$(WixToolsetRootFolder)\Extensibility\src\WixToolset.Extensibility\WixToolset.Extensibility.csproj" Condition=" '$(Configuration)' == 'Debug' And Exists('$(WixToolsetRootFolder)\Extensibility\src\WixToolset.Extensibility\WixToolset.Extensibility.csproj') " />
+    <PackageReference Include="WixToolset.Extensibility" Version="4.0.*" Condition=" '$(Configuration)' == 'Release' Or !Exists('$(WixToolsetRootFolder)\Extensibility\src\WixToolset.Extensibility\WixToolset.Extensibility.csproj') " />
+
+    <ProjectReference Include="$(WixToolsetRootFolder)\Core.Native\src\WixToolset.Core.Native\WixToolset.Core.Native.csproj" Condition=" '$(Configuration)' == 'Debug' And Exists('$(WixToolsetRootFolder)\Core.Native\src\WixToolset.Core.Native\WixToolset.Core.Native.csproj') " />
+
+    <ProjectReference Include="..\WixToolset.Core\WixToolset.Core.csproj" />
+    <PackageReference Include="WixToolset.Core.Native" Version="4.0.*" Condition=" '$(Configuration)' == 'Release' Or !Exists('$(WixToolsetRootFolder)\Core.Native\src\WixToolset.Core.Native\WixToolset.Core.Native.csproj') " />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="WixToolset.Dtf.Resources" Version="4.0.*" />
+    <PackageReference Include="WixToolset.Dtf.WindowsInstaller" Version="4.0.*" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Nerdbank.GitVersioning" Version="2.0.41" PrivateAssets="all" />
+  </ItemGroup>
+</Project>
diff --git a/src/WixToolset.Core/BackendContext.cs b/src/WixToolset.Core/BackendContext.cs
new file mode 100644
index 00000000..7166a3a3
--- /dev/null
+++ b/src/WixToolset.Core/BackendContext.cs
@@ -0,0 +1,16 @@
+// 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
+{
+    using WixToolset.Data;
+
+    public class BackendContext
+    {
+        internal BackendContext()
+        {
+            this.Messaging = Messaging.Instance;
+        }
+
+        public Messaging Messaging { get; }
+    }
+}
diff --git a/src/WixToolset.Core/Bind/DelayedField.cs b/src/WixToolset.Core/Bind/DelayedField.cs
index 181ac3e3..6c56f27c 100644
--- a/src/WixToolset.Core/Bind/DelayedField.cs
+++ b/src/WixToolset.Core/Bind/DelayedField.cs
@@ -1,18 +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.
 
-namespace WixToolset.Bind
+namespace WixToolset.Core.Bind
 {
-    using System;
-    using System.Collections.Generic;
-    using System.Linq;
-    using System.Text;
     using WixToolset.Data;
+    using WixToolset.Extensibility;
 
     /// <summary>
     /// Structure used to hold a row and field that contain binder variables, which need to be resolved
     /// later, once the files have been resolved.
     /// </summary>
-    internal class DelayedField
+    internal class DelayedField : IDelayedField
     {
         /// <summary>
         /// Basic constructor for struct
@@ -28,11 +25,11 @@ namespace WixToolset.Bind
         /// <summary>
         /// The row containing the field.
         /// </summary>
-        public Row Row { get; private set; }
+        public Row Row { get; }
 
         /// <summary>
         /// The field needing further resolving.
         /// </summary>
-        public Field Field { get; private set; }
+        public Field Field { get; }
     }
 }
diff --git a/src/WixToolset.Core/Bind/ExpectedExtractFile.cs b/src/WixToolset.Core/Bind/ExpectedExtractFile.cs
new file mode 100644
index 00000000..fc2b43c7
--- /dev/null
+++ b/src/WixToolset.Core/Bind/ExpectedExtractFile.cs
@@ -0,0 +1,16 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.Core.Bind
+{
+    using System;
+    using WixToolset.Extensibility;
+
+    internal class ExpectedExtractFile : IExpectedExtractFile
+    {
+        public Uri Uri { get; set; }
+
+        public int EmbeddedFileIndex { get; set; }
+
+        public string OutputPath { get; set; }
+    }
+}
diff --git a/src/WixToolset.Core/Bind/ExtractEmbeddedFiles.cs b/src/WixToolset.Core/Bind/ExtractEmbeddedFiles.cs
index 0ecd0096..28fc4817 100644
--- a/src/WixToolset.Core/Bind/ExtractEmbeddedFiles.cs
+++ b/src/WixToolset.Core/Bind/ExtractEmbeddedFiles.cs
@@ -1,6 +1,6 @@
 // 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.Bind
+namespace WixToolset.Core.Bind
 {
     using System;
     using System.Collections.Generic;
@@ -13,11 +13,11 @@ namespace WixToolset.Bind
     /// <summary>
     /// Internal helper class used to extract embedded files.
     /// </summary>
-    internal sealed class ExtractEmbeddedFiles
+    internal class ExtractEmbeddedFiles
     {
         private Dictionary<Uri, SortedList<int, string>> filesWithEmbeddedFiles = new Dictionary<Uri, SortedList<int, string>>();
 
-        public IEnumerable<Uri> Uris { get { return this.filesWithEmbeddedFiles.Keys; } }
+        public IEnumerable<Uri> Uris => this.filesWithEmbeddedFiles.Keys;
 
         /// <summary>
         /// Adds an embedded file index to track and returns the path where the embedded file will be extracted. Duplicates will return the same extract path.
@@ -53,15 +53,30 @@ namespace WixToolset.Bind
             return extractPath;
         }
 
-        public IEnumerable<ExtractFile> GetExtractFilesForUri(Uri uri)
+        public IEnumerable<ExpectedExtractFile> GetExpectedEmbeddedFiles()
         {
-            SortedList<int, string> extracts;
-            if (!filesWithEmbeddedFiles.TryGetValue(uri, out extracts))
+            foreach (var uriWithExtracts in filesWithEmbeddedFiles)
+            {
+                foreach (var extracts in uriWithExtracts.Value)
+                {
+                    yield return new ExpectedExtractFile
+                    {
+                        Uri = uriWithExtracts.Key,
+                        EmbeddedFileIndex = extracts.Key,
+                        OutputPath = extracts.Value,
+                    };
+                }
+            }
+        }
+
+        public IEnumerable<ExpectedExtractFile> GetExtractFilesForUri(Uri uri)
+        {
+            if (!filesWithEmbeddedFiles.TryGetValue(uri, out var extracts))
             {
                 extracts = new SortedList<int, string>();
             }
 
-            return extracts.Select(e => new ExtractFile() { EmbeddedFileIndex = e.Key, OutputPath = e.Value });
+            return extracts.Select(e => new ExpectedExtractFile() { Uri = uri, EmbeddedFileIndex = e.Key, OutputPath = e.Value });
         }
 
         private string HashUri(string uri)
@@ -72,12 +87,5 @@ namespace WixToolset.Bind
                 return Convert.ToBase64String(hash).TrimEnd('=').Replace('+', '-').Replace('/', '_');
             }
         }
-
-        internal struct ExtractFile
-        {
-            public int EmbeddedFileIndex { get; set; }
-
-            public string OutputPath { get; set; }
-        }
     }
 }
diff --git a/src/WixToolset.Core/Bind/ExtractEmbeddedFilesCommand.cs b/src/WixToolset.Core/Bind/ExtractEmbeddedFilesCommand.cs
index 68bfd8d7..7de40fb8 100644
--- a/src/WixToolset.Core/Bind/ExtractEmbeddedFilesCommand.cs
+++ b/src/WixToolset.Core/Bind/ExtractEmbeddedFilesCommand.cs
@@ -1,19 +1,26 @@
 // 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.Bind
+namespace WixToolset.Core.Bind
 {
+    using System.Collections.Generic;
     using System.IO;
+    using System.Linq;
     using System.Reflection;
     using WixToolset.Data;
+    using WixToolset.Extensibility;
 
-    internal class ExtractEmbeddedFilesCommand : ICommand
+    public class ExtractEmbeddedFilesCommand
     {
-        public ExtractEmbeddedFiles FilesWithEmbeddedFiles { private get; set; }
+        public IEnumerable<IExpectedExtractFile> FilesWithEmbeddedFiles { private get; set; }
 
         public void Execute()
         {
-            foreach (var baseUri in this.FilesWithEmbeddedFiles.Uris)
+            var group = this.FilesWithEmbeddedFiles.GroupBy(e => e.Uri);
+
+            foreach (var expectedEmbeddedFileByUri in group)
             {
+                var baseUri = expectedEmbeddedFileByUri.Key;
+
                 Stream stream = null;
                 try
                 {
@@ -34,18 +41,20 @@ namespace WixToolset.Bind
 
                     using (FileStructure fs = FileStructure.Read(stream))
                     {
-                        foreach (var embeddedFile in this.FilesWithEmbeddedFiles.GetExtractFilesForUri(baseUri))
+                        var uniqueIndicies = new SortedSet<int>();
+
+                        foreach (var embeddedFile in expectedEmbeddedFileByUri)
                         {
-                            fs.ExtractEmbeddedFile(embeddedFile.EmbeddedFileIndex, embeddedFile.OutputPath);
+                            if (uniqueIndicies.Add(embeddedFile.EmbeddedFileIndex))
+                            {
+                                fs.ExtractEmbeddedFile(embeddedFile.EmbeddedFileIndex, embeddedFile.OutputPath);
+                            }
                         }
                     }
                 }
                 finally
                 {
-                    if (null != stream)
-                    {
-                        stream.Close();
-                    }
+                    stream?.Close();
                 }
             }
         }
diff --git a/src/WixToolset.Core/Bind/Databases/FileFacade.cs b/src/WixToolset.Core/Bind/FileFacade.cs
index 37115c97..aaa6b7d3 100644
--- a/src/WixToolset.Core/Bind/Databases/FileFacade.cs
+++ b/src/WixToolset.Core/Bind/FileFacade.cs
@@ -1,6 +1,6 @@
 // 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.Bind.Databases
+namespace WixToolset.Core.Bind
 {
     using System.Collections.Generic;
     using WixToolset.Data;
diff --git a/src/WixToolset.Core/Bind/FileResolver.cs b/src/WixToolset.Core/Bind/FileResolver.cs
new file mode 100644
index 00000000..8d624e6f
--- /dev/null
+++ b/src/WixToolset.Core/Bind/FileResolver.cs
@@ -0,0 +1,231 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.Core.Bind
+{
+    using System;
+    using System.Collections.Generic;
+    using System.IO;
+    using System.Linq;
+    using System.Runtime.InteropServices;
+    using WixToolset.Data;
+    using WixToolset.Data.Bind;
+    using WixToolset.Extensibility;
+
+    internal class FileResolver
+    {
+        private const string BindPathOpenString = "!(bindpath.";
+
+        private FileResolver(IEnumerable<BindPath> bindPaths)
+        {
+            this.BindPaths = (bindPaths ?? Array.Empty<BindPath>()).ToLookup(b => b.Stage);
+            this.RebaseTarget = this.BindPaths[BindStage.Target].Any();
+            this.RebaseUpdated = this.BindPaths[BindStage.Updated].Any();
+        }
+
+        public FileResolver(IEnumerable<BindPath> bindPaths, IEnumerable<IBinderExtension> extensions) : this(bindPaths)
+        {
+            this.BinderExtensions = extensions ?? Array.Empty<IBinderExtension>();
+        }
+
+        public FileResolver(IEnumerable<BindPath> bindPaths, IEnumerable<ILibrarianExtension> extensions) : this(bindPaths)
+        {
+            this.LibrarianExtensions = extensions ?? Array.Empty<ILibrarianExtension>();
+        }
+
+        private ILookup<BindStage, BindPath> BindPaths { get; }
+
+        public bool RebaseTarget { get; }
+
+        public bool RebaseUpdated { get; }
+
+        private IEnumerable<IBinderExtension> BinderExtensions { get; }
+
+        private IEnumerable<ILibrarianExtension> LibrarianExtensions { get; }
+
+        /// <summary>
+        /// Copies a file.
+        /// </summary>
+        /// <param name="source">The file to copy.</param>
+        /// <param name="destination">The destination file.</param>
+        /// <param name="overwrite">true if the destination file can be overwritten; otherwise, false.</param>
+        public bool CopyFile(string source, string destination, bool overwrite)
+        {
+            foreach (var extension in this.BinderExtensions)
+            {
+                if (extension.CopyFile(source, destination, overwrite))
+                {
+                    return true;
+                }
+            }
+
+            if (overwrite && File.Exists(destination))
+            {
+                File.Delete(destination);
+            }
+
+            if (!CreateHardLink(destination, source, IntPtr.Zero))
+            {
+#if DEBUG
+                int er = Marshal.GetLastWin32Error();
+#endif
+
+                File.Copy(source, destination, overwrite);
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Moves a file.
+        /// </summary>
+        /// <param name="source">The file to move.</param>
+        /// <param name="destination">The destination file.</param>
+        public bool MoveFile(string source, string destination, bool overwrite)
+        {
+            foreach (var extension in this.BinderExtensions)
+            {
+                if (extension.MoveFile(source, destination, overwrite))
+                {
+                    return true;
+                }
+            }
+
+            if (overwrite && File.Exists(destination))
+            {
+                File.Delete(destination);
+            }
+
+            var directory = Path.GetDirectoryName(destination);
+            if (!String.IsNullOrEmpty(directory))
+            {
+                Directory.CreateDirectory(directory);
+            }
+
+            File.Move(source, destination);
+
+            return true;
+        }
+
+        public string Resolve(SourceLineNumber sourceLineNumbers, string table, string path)
+        {
+            foreach (var extension in this.LibrarianExtensions)
+            {
+                var resolved = extension.Resolve(sourceLineNumbers, table, path);
+
+                if (null != resolved)
+                {
+                    return resolved;
+                }
+            }
+
+            return this.ResolveUsingBindPaths(path, table, sourceLineNumbers, BindStage.Normal);
+        }
+
+        /// <summary>
+        /// Resolves the source path of a file using binder extensions.
+        /// </summary>
+        /// <param name="source">Original source value.</param>
+        /// <param name="type">Optional type of source file being resolved.</param>
+        /// <param name="sourceLineNumbers">Optional source line of source file being resolved.</param>
+        /// <param name="bindStage">The binding stage used to determine what collection of bind paths will be used</param>
+        /// <returns>Should return a valid path for the stream to be imported.</returns>
+        public string ResolveFile(string source, string type, SourceLineNumber sourceLineNumbers, BindStage bindStage)
+        {
+            foreach (var extension in this.BinderExtensions)
+            {
+                var resolved = extension.ResolveFile(source, type, sourceLineNumbers, bindStage);
+
+                if (null != resolved)
+                {
+                    return resolved;
+                }
+            }
+
+            return this.ResolveUsingBindPaths(source, type, sourceLineNumbers, bindStage);
+        }
+
+        private string ResolveUsingBindPaths(string source, string type, SourceLineNumber sourceLineNumbers, BindStage bindStage)
+        {
+            string resolved = null;
+
+            // If the file exists, we're good to go.
+            if (CheckFileExists(source))
+            {
+                resolved = source;
+            }
+            else if (Path.IsPathRooted(source)) // path is rooted so bindpaths won't help, bail since the file apparently doesn't exist.
+            {
+                resolved = null;
+            }
+            else // not a rooted path so let's try applying all the different source resolution options.
+            {
+                string bindName = String.Empty;
+                var path = source;
+                string pathWithoutSourceDir = null;
+
+                if (source.StartsWith(BindPathOpenString, StringComparison.Ordinal))
+                {
+                    int closeParen = source.IndexOf(')', BindPathOpenString.Length);
+                    if (-1 != closeParen)
+                    {
+                        bindName = source.Substring(BindPathOpenString.Length, closeParen - BindPathOpenString.Length);
+                        path = source.Substring(BindPathOpenString.Length + bindName.Length + 1); // +1 for the closing brace.
+                        path = path.TrimStart('\\'); // remove starting '\\' char so the path doesn't look rooted.
+                    }
+                }
+                else if (source.StartsWith("SourceDir\\", StringComparison.Ordinal) || source.StartsWith("SourceDir/", StringComparison.Ordinal))
+                {
+                    pathWithoutSourceDir = path.Substring(10);
+                }
+
+                var bindPaths = this.BindPaths[bindStage];
+
+                foreach (var bindPath in bindPaths)
+                {
+                    if (!String.IsNullOrEmpty(pathWithoutSourceDir))
+                    {
+                        var filePath = Path.Combine(bindPath.Path, pathWithoutSourceDir);
+
+                        if (CheckFileExists(filePath))
+                        {
+                            resolved = filePath;
+                        }
+                    }
+
+                    if (String.IsNullOrEmpty(resolved))
+                    {
+                        var filePath = Path.Combine(bindPath.Path, path);
+
+                        if (CheckFileExists(filePath))
+                        {
+                            resolved = filePath;
+                        }
+                    }
+                }
+            }
+
+            if (null == resolved)
+            {
+                throw new WixFileNotFoundException(sourceLineNumbers, source, type);
+            }
+
+            // Didn't find the file.
+            return resolved;
+        }
+
+        private static bool CheckFileExists(string path)
+        {
+            try
+            {
+                return File.Exists(path);
+            }
+            catch (ArgumentException)
+            {
+                throw new WixException(WixErrors.IllegalCharactersInPath(path));
+            }
+        }
+
+        [DllImport("Kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
+        private static extern bool CreateHardLink(string lpFileName, string lpExistingFileName, IntPtr lpSecurityAttributes);
+    }
+}
diff --git a/src/WixToolset.Core/Bind/FileTransfer.cs b/src/WixToolset.Core/Bind/FileTransfer.cs
deleted file mode 100644
index 64bbc5f1..00000000
--- a/src/WixToolset.Core/Bind/FileTransfer.cs
+++ /dev/null
@@ -1,113 +0,0 @@
-// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
-
-namespace WixToolset.Bind
-{
-    using System;
-    using System.IO;
-    using WixToolset;
-    using WixToolset.Data;
-
-    /// <summary>
-    /// Structure used for all file transfer information.
-    /// </summary>
-    internal class FileTransfer
-    {
-        /// <summary>Source path to file.</summary>
-        public string Source { get; set; }
-
-        /// <summary>Destination path for file.</summary>
-        public string Destination { get; set; }
-
-        /// <summary>Flag if file should be moved (optimal).</summary>
-        public bool Move { get; set; }
-
-        /// <summary>Optional source line numbers where this file transfer orginated.</summary>
-        public SourceLineNumber SourceLineNumbers { get; set; }
-
-        /// <summary>Optional type of file this transfer is moving or copying.</summary>
-        public string Type { get; set; }
-
-        /// <summary>Indicates whether the file transer was a built by this build or copied from other some build.</summary>
-        internal bool Built { get; set; }
-
-        /// <summary>Set during layout of media when the file transfer when the source and target resolve to the same path.</summary>
-        internal bool Redundant { get; set; }
-
-        /// <summary>
-        /// Prefer the TryCreate() method to create FileTransfer objects.
-        /// </summary>
-        /// <param name="source">Source path to file.</param>
-        /// <param name="destination">Destination path for file.</param>
-        /// <param name="move">File if file should be moved (optimal).</param>
-        /// <param name="type">Optional type of file this transfer is transferring.</param>
-        /// <param name="sourceLineNumbers">Optional source line numbers wher this transfer originated.</param>
-        public FileTransfer(string source, string destination, bool move, string type = null, SourceLineNumber sourceLineNumbers = null)
-        {
-            this.Source = source;
-            this.Destination = destination;
-            this.Move = move;
-
-            this.Type = type;
-            this.SourceLineNumbers = sourceLineNumbers;
-        }
-
-        /// <summary>
-        /// Creates a file transfer if the source and destination are different.
-        /// </summary>
-        /// <param name="source">Source path to file.</param>
-        /// <param name="destination">Destination path for file.</param>
-        /// <param name="move">File if file should be moved (optimal).</param>
-        /// <param name="type">Optional type of file this transfer is transferring.</param>
-        /// <param name="sourceLineNumbers">Optional source line numbers wher this transfer originated.</param>
-        /// <returns>true if the source and destination are the different, false if no file transfer is created.</returns>
-        public static bool TryCreate(string source, string destination, bool move, string type, SourceLineNumber sourceLineNumbers, out FileTransfer transfer)
-        {
-            string sourceFullPath = GetValidatedFullPath(sourceLineNumbers, source);
-
-            string fileLayoutFullPath = GetValidatedFullPath(sourceLineNumbers, destination);
-
-            // if the current source path (where we know that the file already exists) and the resolved
-            // path as dictated by the Directory table are not the same, then propagate the file.  The
-            // image that we create may have already been done by some other process other than the linker, so 
-            // there is no reason to copy the files to the resolved source if they are already there.
-            if (String.Equals(sourceFullPath, fileLayoutFullPath, StringComparison.OrdinalIgnoreCase))
-            {
-                transfer = null;
-                return false;
-            }
-
-            transfer = new FileTransfer(source, destination, move, type, sourceLineNumbers);
-            return true;
-        }
-
-        private static string GetValidatedFullPath(SourceLineNumber sourceLineNumbers, string path)
-        {
-            string result;
-
-            try
-            {
-                result = Path.GetFullPath(path);
-
-                string filename = Path.GetFileName(result);
-
-                foreach (string reservedName in Common.ReservedFileNames)
-                {
-                    if (reservedName.Equals(filename, StringComparison.OrdinalIgnoreCase))
-                    {
-                        throw new WixException(WixErrors.InvalidFileName(sourceLineNumbers, path));
-                    }
-                }
-            }
-            catch (System.ArgumentException)
-            {
-                throw new WixException(WixErrors.InvalidFileName(sourceLineNumbers, path));
-            }
-            catch (System.IO.PathTooLongException)
-            {
-                throw new WixException(WixErrors.PathTooLong(sourceLineNumbers, path));
-            }
-
-            return result;
-        }
-    }
-}
diff --git a/src/WixToolset.Core/Bind/ResolveDelayedFieldsCommand.cs b/src/WixToolset.Core/Bind/ResolveDelayedFieldsCommand.cs
index 4ffe9e82..15365c2a 100644
--- a/src/WixToolset.Core/Bind/ResolveDelayedFieldsCommand.cs
+++ b/src/WixToolset.Core/Bind/ResolveDelayedFieldsCommand.cs
@@ -1,23 +1,22 @@
 // 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.Bind
+namespace WixToolset.Core.Bind
 {
     using System;
     using System.Collections.Generic;
     using System.Globalization;
-    using System.Linq;
-    using System.Text;
     using WixToolset.Data;
+    using WixToolset.Extensibility;
 
     /// <summary>
     /// Resolves the fields which had variables that needed to be resolved after the file information
     /// was loaded.
     /// </summary>
-    internal class ResolveDelayedFieldsCommand : ICommand
+    public class ResolveDelayedFieldsCommand : ICommand
     {
         public OutputType OutputType { private get; set;}
 
-        public IEnumerable<DelayedField> DelayedFields { private get; set;}
+        public IEnumerable<IDelayedField> DelayedFields { private get; set;}
 
         public IDictionary<string, string> VariableCache { private get; set; }
 
@@ -29,9 +28,9 @@ namespace WixToolset.Bind
         /// <param name="modularizationGuid">The modularization guid (used in case of a merge module).</param>
         public void Execute()
         {
-            List<DelayedField> deferredFields = new List<DelayedField>();
+            var deferredFields = new List<IDelayedField>();
 
-            foreach (DelayedField delayedField in this.DelayedFields)
+            foreach (IDelayedField delayedField in this.DelayedFields)
             {
                 try
                 {
@@ -43,7 +42,7 @@ namespace WixToolset.Bind
                         string value = WixVariableResolver.ResolveDelayedVariables(propertyRow.SourceLineNumbers, (string)delayedField.Field.Data, this.VariableCache);
 
                         // update the variable cache with the new value
-                        string key = String.Concat("property.", BindDatabaseCommand.Demodularize(this.OutputType, this.ModularizationGuid, (string)propertyRow[0]));
+                        string key = String.Concat("property.", Common.Demodularize(this.OutputType, this.ModularizationGuid, (string)propertyRow[0]));
                         this.VariableCache[key] = value;
 
                         // update the field data
diff --git a/src/WixToolset.Core/Bind/ResolveFieldsCommand.cs b/src/WixToolset.Core/Bind/ResolveFieldsCommand.cs
index 4caec9b4..f4f4f9e8 100644
--- a/src/WixToolset.Core/Bind/ResolveFieldsCommand.cs
+++ b/src/WixToolset.Core/Bind/ResolveFieldsCommand.cs
@@ -1,29 +1,32 @@
 // 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.Bind
+namespace WixToolset.Core.Bind
 {
     using System.Collections.Generic;
     using WixToolset.Data;
+    using WixToolset.Data.Bind;
     using WixToolset.Extensibility;
 
     /// <summary>
     /// Resolve source fields in the tables included in the output
     /// </summary>
-    internal class ResolveFieldsCommand : ICommand
+    internal class ResolveFieldsCommand
     {
-        public TableIndexedCollection Tables { private get; set; }
+        public bool BuildingPatch { private get; set; }
 
-        public ExtractEmbeddedFiles FilesWithEmbeddedFiles { private get; set; }
+        public IBindVariableResolver BindVariableResolver { private get; set; }
 
-        public BinderFileManagerCore FileManagerCore { private get; set; }
+        public IEnumerable<BindPath> BindPaths { private get; set; }
 
-        public IEnumerable<IBinderFileManager> FileManagers { private get; set; }
+        public IEnumerable<IBinderExtension> Extensions { private get; set; }
 
-        public bool SupportDelayedResolution { private get; set; }
+        public ExtractEmbeddedFiles FilesWithEmbeddedFiles { private get; set; }
+
+        public string IntermediateFolder { private get; set; }
 
-        public string TempFilesLocation { private get; set; }
+        public TableIndexedCollection Tables { private get; set; }
 
-        public WixVariableResolver WixVariableResolver { private get; set; }
+        public bool SupportDelayedResolution { private get; set; }
 
         public IEnumerable<DelayedField> DelayedFields { get; private set; }
 
@@ -31,6 +34,8 @@ namespace WixToolset.Bind
         {
             List<DelayedField> delayedFields = this.SupportDelayedResolution ? new List<DelayedField>() : null;
 
+            var fileResolver = new FileResolver(this.BindPaths, this.Extensions);
+
             foreach (Table table in this.Tables)
             {
                 foreach (Row row in table.Rows)
@@ -46,7 +51,7 @@ namespace WixToolset.Bind
                             // resolve localization and wix variables
                             if (field.Data is string)
                             {
-                                field.Data = this.WixVariableResolver.ResolveVariables(row.SourceLineNumbers, field.AsString(), false, ref isDefault, ref delayedResolve);
+                                field.Data = this.BindVariableResolver.ResolveVariables(row.SourceLineNumbers, field.AsString(), false, out isDefault, out delayedResolve);
                                 if (delayedResolve)
                                 {
                                     delayedFields.Add(new DelayedField(row, field));
@@ -74,7 +79,7 @@ namespace WixToolset.Bind
                             // File is embedded and path to it was not modified above.
                             if (objectField.EmbeddedFileIndex.HasValue && isDefault)
                             {
-                                string extractPath = this.FilesWithEmbeddedFiles.AddEmbeddedFileIndex(objectField.BaseUri, objectField.EmbeddedFileIndex.Value, this.TempFilesLocation);
+                                string extractPath = this.FilesWithEmbeddedFiles.AddEmbeddedFileIndex(objectField.BaseUri, objectField.EmbeddedFileIndex.Value, this.IntermediateFolder);
 
                                 // Set the path to the embedded file once where it will be extracted.
                                 objectField.Data = extractPath;
@@ -83,7 +88,7 @@ namespace WixToolset.Bind
                             {
                                 try
                                 {
-                                    if (OutputType.Patch != this.FileManagerCore.Output.Type) // Normal binding for non-Patch scenario such as link (light.exe)
+                                    if (!this.BuildingPatch) // Normal binding for non-Patch scenario such as link (light.exe)
                                     {
                                         // keep a copy of the un-resolved data for future replay. This will be saved into wixpdb file
                                         if (null == objectField.UnresolvedData)
@@ -92,12 +97,12 @@ namespace WixToolset.Bind
                                         }
 
                                         // resolve the path to the file
-                                        objectField.Data = this.ResolveFile((string)objectField.Data, table.Name, row.SourceLineNumbers, BindStage.Normal);
+                                        objectField.Data = fileResolver.ResolveFile((string)objectField.Data, table.Name, row.SourceLineNumbers, BindStage.Normal);
                                     }
-                                    else if (!(this.FileManagerCore.RebaseTarget || this.FileManagerCore.RebaseUpdated)) // Normal binding for Patch Scenario (normal patch, no re-basing logic)
+                                    else if (!fileResolver.RebaseTarget && !fileResolver.RebaseUpdated) // Normal binding for Patch Scenario (normal patch, no re-basing logic)
                                     {
                                         // resolve the path to the file
-                                        objectField.Data = this.ResolveFile((string)objectField.Data, table.Name, row.SourceLineNumbers, BindStage.Normal);
+                                        objectField.Data = fileResolver.ResolveFile((string)objectField.Data, table.Name, row.SourceLineNumbers, BindStage.Normal);
                                     }
                                     else // Re-base binding path scenario caused by pyro.exe -bt -bu
                                     {
@@ -106,7 +111,7 @@ namespace WixToolset.Bind
 
                                         // if -bu is used in pyro command, this condition holds true and the tool
                                         // will use pre-resolved source for new wixpdb file
-                                        if (this.FileManagerCore.RebaseUpdated)
+                                        if (fileResolver.RebaseUpdated)
                                         {
                                             // try to use the unResolved Source if it exists.
                                             // New version of wixpdb file keeps a copy of pre-resolved Source. i.e. !(bindpath.test)\foo.dll
@@ -117,7 +122,7 @@ namespace WixToolset.Bind
                                             }
                                         }
 
-                                        objectField.Data = this.ResolveFile(filePathToResolve, table.Name, row.SourceLineNumbers, BindStage.Updated);
+                                        objectField.Data = fileResolver.ResolveFile(filePathToResolve, table.Name, row.SourceLineNumbers, BindStage.Updated);
                                     }
                                 }
                                 catch (WixFileNotFoundException)
@@ -127,10 +132,10 @@ namespace WixToolset.Bind
                                 }
                             }
 
-                            isDefault = true;
                             if (null != objectField.PreviousData)
                             {
-                                objectField.PreviousData = this.WixVariableResolver.ResolveVariables(row.SourceLineNumbers, objectField.PreviousData, false, ref isDefault);
+                                objectField.PreviousData = this.BindVariableResolver.ResolveVariables(row.SourceLineNumbers, objectField.PreviousData, false, out isDefault);
+
                                 if (!Messaging.Instance.EncounteredError) // TODO: make this error handling more specific to just the failure to resolve variables in this field.
                                 {
                                     // file is compressed in a cabinet (and not modified above)
@@ -142,7 +147,7 @@ namespace WixToolset.Bind
                                             objectField.PreviousBaseUri = objectField.BaseUri;
                                         }
 
-                                        string extractPath = this.FilesWithEmbeddedFiles.AddEmbeddedFileIndex(objectField.PreviousBaseUri, objectField.PreviousEmbeddedFileIndex.Value, this.TempFilesLocation);
+                                        string extractPath = this.FilesWithEmbeddedFiles.AddEmbeddedFileIndex(objectField.PreviousBaseUri, objectField.PreviousEmbeddedFileIndex.Value, this.IntermediateFolder);
 
                                         // set the path to the file once its extracted from the cabinet
                                         objectField.PreviousData = extractPath;
@@ -151,14 +156,14 @@ namespace WixToolset.Bind
                                     {
                                         try
                                         {
-                                            if (!this.FileManagerCore.RebaseTarget && !this.FileManagerCore.RebaseUpdated)
+                                            if (!fileResolver.RebaseTarget && !fileResolver.RebaseUpdated)
                                             {
                                                 // resolve the path to the file
-                                                objectField.PreviousData = this.ResolveFile((string)objectField.PreviousData, table.Name, row.SourceLineNumbers, BindStage.Normal);
+                                                objectField.PreviousData = fileResolver.ResolveFile((string)objectField.PreviousData, table.Name, row.SourceLineNumbers, BindStage.Normal);
                                             }
                                             else
                                             {
-                                                if (this.FileManagerCore.RebaseTarget)
+                                                if (fileResolver.RebaseTarget)
                                                 {
                                                     // if -bt is used, it come here
                                                     // Try to use the original unresolved source from either target build or update build
@@ -172,7 +177,7 @@ namespace WixToolset.Bind
                                                 }
 
                                                 // resolve the path to the file
-                                                objectField.PreviousData = this.ResolveFile((string)objectField.PreviousData, table.Name, row.SourceLineNumbers, BindStage.Target);
+                                                objectField.PreviousData = fileResolver.ResolveFile((string)objectField.PreviousData, table.Name, row.SourceLineNumbers, BindStage.Target);
 
                                             }
                                         }
@@ -192,24 +197,28 @@ namespace WixToolset.Bind
             this.DelayedFields = delayedFields;
         }
 
+#if false
         private string ResolveFile(string source, string type, SourceLineNumber sourceLineNumbers, BindStage bindStage = BindStage.Normal)
         {
             string path = null;
-            foreach (IBinderFileManager fileManager in this.FileManagers)
+            foreach (var extension in this.Extensions)
             {
-                path = fileManager.ResolveFile(source, type, sourceLineNumbers, bindStage);
+                path = extension.ResolveFile(source, type, sourceLineNumbers, bindStage);
                 if (null != path)
                 {
                     break;
                 }
             }
 
-            if (null == path)
-            {
-                throw new WixFileNotFoundException(sourceLineNumbers, source, type);
-            }
+            throw new NotImplementedException(); // need to do default binder stuff
+
+            //if (null == path)
+            //{
+            //    throw new WixFileNotFoundException(sourceLineNumbers, source, type);
+            //}
 
-            return path;
+            //return path;
         }
+#endif
     }
 }
diff --git a/src/WixToolset.Core/Bind/ResolveResult.cs b/src/WixToolset.Core/Bind/ResolveResult.cs
new file mode 100644
index 00000000..13f25054
--- /dev/null
+++ b/src/WixToolset.Core/Bind/ResolveResult.cs
@@ -0,0 +1,14 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.Core.Bind
+{
+    using System.Collections.Generic;
+    using WixToolset.Extensibility;
+
+    public class ResolveResult
+    {
+        public IEnumerable<IExpectedExtractFile> ExpectedEmbeddedFiles { get; set; }
+
+        public IEnumerable<IDelayedField> DelayedFields { get; set; }
+    }
+}
\ No newline at end of file
diff --git a/src/WixToolset.Core/Bind/ResolvedDirectory.cs b/src/WixToolset.Core/Bind/ResolvedDirectory.cs
index 6985f95d..fca706d8 100644
--- a/src/WixToolset.Core/Bind/ResolvedDirectory.cs
+++ b/src/WixToolset.Core/Bind/ResolvedDirectory.cs
@@ -5,7 +5,7 @@ namespace WixToolset.Bind
     /// <summary>
     /// Structure used for resolved directory information.
     /// </summary>
-    internal struct ResolvedDirectory
+    public struct ResolvedDirectory
     {
         /// <summary>The directory parent.</summary>
         public string DirectoryParent;
diff --git a/src/WixToolset.Core/Bind/TransferFilesCommand.cs b/src/WixToolset.Core/Bind/TransferFilesCommand.cs
index 719b8b20..f116569c 100644
--- a/src/WixToolset.Core/Bind/TransferFilesCommand.cs
+++ b/src/WixToolset.Core/Bind/TransferFilesCommand.cs
@@ -1,29 +1,37 @@
 // 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.Bind
+namespace WixToolset.Core.Bind
 {
     using System;
     using System.Collections.Generic;
     using System.IO;
     using System.Security.AccessControl;
     using WixToolset.Data;
+    using WixToolset.Data.Bind;
     using WixToolset.Extensibility;
 
-    internal class TransferFilesCommand : ICommand
+    internal class TransferFilesCommand
     {
-        public IEnumerable<IBinderFileManager> FileManagers { private get; set; }
+        public TransferFilesCommand(IEnumerable<BindPath> bindPaths, IEnumerable<IBinderExtension> extensions, IEnumerable<FileTransfer> fileTransfers, bool suppressAclReset)
+        {
+            this.FileResolver = new FileResolver(bindPaths, extensions);
+            this.FileTransfers = fileTransfers;
+            this.SuppressAclReset = suppressAclReset;
+        }
+
+        private FileResolver FileResolver { get; }
 
-        public IEnumerable<FileTransfer> FileTransfers { private get; set; }
+        private IEnumerable<FileTransfer> FileTransfers { get; }
 
-        public bool SuppressAclReset { private get; set; }
+        private bool SuppressAclReset { get; }
 
         public void Execute()
         {
             List<string> destinationFiles = new List<string>();
 
-            foreach (FileTransfer fileTransfer in this.FileTransfers)
+            foreach (var fileTransfer in this.FileTransfers)
             {
-                string fileSource = this.ResolveFile(fileTransfer.Source, fileTransfer.Type, fileTransfer.SourceLineNumbers, BindStage.Normal);
+                string fileSource = this.FileResolver.ResolveFile(fileTransfer.Source, fileTransfer.Type, fileTransfer.SourceLineNumbers, BindStage.Normal);
 
                 // If the source and destination are identical, then there's nothing to do here
                 if (0 == String.Compare(fileSource, fileTransfer.Destination, StringComparison.OrdinalIgnoreCase))
@@ -165,44 +173,17 @@ namespace WixToolset.Bind
             }
         }
 
-        private string ResolveFile(string source, string type, SourceLineNumber sourceLineNumbers, BindStage bindStage)
+        private void TransferFile(bool move, string source, string destination)
         {
-            string path = null;
-            foreach (IBinderFileManager fileManager in this.FileManagers)
-            {
-                path = fileManager.ResolveFile(source, type, sourceLineNumbers, bindStage);
-                if (null != path)
-                {
-                    break;
-                }
-            }
+            bool complete = false;
 
-            if (null == path)
+            if (move)
             {
-                throw new WixFileNotFoundException(sourceLineNumbers, source, type);
+                complete = this.FileResolver.MoveFile(source, destination, true);
             }
-
-            return path;
-        }
-
-        private void TransferFile(bool move, string source, string destination)
-        {
-            bool complete = false;
-            foreach (IBinderFileManager fileManager in this.FileManagers)
+            else
             {
-                if (move)
-                {
-                    complete = fileManager.MoveFile(source, destination, true);
-                }
-                else
-                {
-                    complete = fileManager.CopyFile(source, destination, true);
-                }
-
-                if (complete)
-                {
-                    break;
-                }
+                complete = this.FileResolver.CopyFile(source, destination, true);
             }
 
             if (!complete)
diff --git a/src/WixToolset.Core/BindContext.cs b/src/WixToolset.Core/BindContext.cs
new file mode 100644
index 00000000..499f3245
--- /dev/null
+++ b/src/WixToolset.Core/BindContext.cs
@@ -0,0 +1,57 @@
+// 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
+{
+    using System.Collections.Generic;
+    using WixToolset.Data;
+    using WixToolset.Extensibility;
+
+    public class BindContext : IBindContext
+    {
+        public Messaging Messaging { get; set; }
+
+        public IEnumerable<BindPath> BindPaths { get; set; }
+
+        public int CabbingThreadCount { get; set; }
+
+        public string CabCachePath { get; set; }
+
+        public int Codepage { get; set; }
+
+        public CompressionLevel DefaultCompressionLevel { get; set; }
+
+        public IEnumerable<IDelayedField> DelayedFields { get; set; }
+
+        public IEnumerable<IExpectedExtractFile> ExpectedEmbeddedFiles { get; set; }
+
+        public IExtensionManager ExtensionManager { get; set; }
+
+        public IEnumerable<IBinderExtension> Extensions { get; set; }
+
+        public IEnumerable<string> Ices { get; set; }
+
+        public string IntermediateFolder { get; set; }
+
+        public Output IntermediateRepresentation { get; set; }
+
+        public string OutputPath { get; set; }
+
+        public string OutputPdbPath { get; set; }
+
+        public bool SuppressAclReset { get; set; }
+
+        public IEnumerable<string> SuppressIces { get; set; }
+
+        public bool SuppressValidation { get; set; }
+
+        public IBindVariableResolver WixVariableResolver { get; set; }
+
+        public string ContentsFile { get; set; }
+
+        public string OutputsFile { get; set; }
+
+        public string BuiltOutputsFile { get; set; }
+
+        public string WixprojectFile { get; set; }
+    }
+}
diff --git a/src/WixToolset.Core/Binder.cs b/src/WixToolset.Core/Binder.cs
index 18ad2d62..43c15634 100644
--- a/src/WixToolset.Core/Binder.cs
+++ b/src/WixToolset.Core/Binder.cs
@@ -1,6 +1,6 @@
 // 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
+namespace WixToolset.Core
 {
     using System;
     using System.Collections;
@@ -11,105 +11,72 @@ namespace WixToolset
     using System.Linq;
     using System.Reflection;
     using WixToolset.Bind;
+    using WixToolset.Core.Bind;
     using WixToolset.Data;
+    using WixToolset.Data.Bind;
     using WixToolset.Data.Rows;
     using WixToolset.Extensibility;
-    using WixToolset.Msi;
-
-    // TODO: (4.0) Refactor so that these don't need to be copied.
-    // Copied verbatim from ext\UtilExtension\wixext\UtilCompiler.cs
-    [Flags]
-    internal enum WixFileSearchAttributes
-    {
-        Default = 0x001,
-        MinVersionInclusive = 0x002,
-        MaxVersionInclusive = 0x004,
-        MinSizeInclusive = 0x008,
-        MaxSizeInclusive = 0x010,
-        MinDateInclusive = 0x020,
-        MaxDateInclusive = 0x040,
-        WantVersion = 0x080,
-        WantExists = 0x100,
-        IsDirectory = 0x200,
-    }
-
-    [Flags]
-    internal enum WixRegistrySearchAttributes
-    {
-        Raw = 0x01,
-        Compatible = 0x02,
-        ExpandEnvironmentVariables = 0x04,
-        WantValue = 0x08,
-        WantExists = 0x10,
-        Win64 = 0x20,
-    }
-
-    internal enum WixComponentSearchAttributes
-    {
-        KeyPath = 0x1,
-        State = 0x2,
-        WantDirectory = 0x4,
-    }
-
-    [Flags]
-    internal enum WixProductSearchAttributes
-    {
-        Version = 0x1,
-        Language = 0x2,
-        State = 0x4,
-        Assignment = 0x8,
-        UpgradeCode = 0x10,
-    }
 
     /// <summary>
     /// Binder of the WiX toolset.
     /// </summary>
     public sealed class Binder
     {
-        private BinderCore core;
-        private BinderFileManagerCore fileManagerCore;
-        private List<IBinderExtension> extensions;
-        private List<IBinderFileManager> fileManagers;
-        private List<InspectorExtension> inspectorExtensions;
+        //private BinderCore core;
+        //private List<IBinderExtension> extensions;
+        //private List<IBinderFileManager> fileManagers;
 
         public Binder()
         {
-            this.DefaultCompressionLevel = CompressionLevel.High;
+            //this.DefaultCompressionLevel = CompressionLevel.High;
 
-            this.BindPaths = new List<BindPath>();
-            this.TargetBindPaths = new List<BindPath>();
-            this.UpdatedBindPaths = new List<BindPath>();
+            //this.BindPaths = new List<BindPath>();
+            //this.TargetBindPaths = new List<BindPath>();
+            //this.UpdatedBindPaths = new List<BindPath>();
 
-            this.extensions = new List<IBinderExtension>();
-            this.fileManagers = new List<IBinderFileManager>();
-            this.inspectorExtensions = new List<InspectorExtension>();
+            //this.extensions = new List<IBinderExtension>();
+            //this.fileManagers = new List<IBinderFileManager>();
+            //this.inspectorExtensions = new List<InspectorExtension>();
 
-            this.Ices = new List<string>();
-            this.SuppressIces = new List<string>();
+            //this.Ices = new List<string>();
+            //this.SuppressIces = new List<string>();
         }
 
-        public string ContentsFile { private get; set; }
+        public Binder(BindContext context)
+        {
+            this.Context = context;
+
+            this.TableDefinitions = WindowsInstallerStandard.GetTableDefinitions();
+        }
+
+        private BindContext Context { get; }
+
+        private TableDefinitionCollection TableDefinitions { get; }
+
+        //public IEnumerable<IBackendFactory> BackendFactories { get; set; }
 
-        public string OutputsFile { private get; set; }
+        //public string ContentsFile { private get; set; }
 
-        public string BuiltOutputsFile { private get; set; }
+        //public string OutputsFile { private get; set; }
 
-        public string WixprojectFile { private get; set; }
+        //public string BuiltOutputsFile { private get; set; }
+
+        //public string WixprojectFile { private get; set; }
 
         /// <summary>
         /// Gets the list of bindpaths.
         /// </summary>
-        public List<BindPath> BindPaths { get; private set; }
+        //public List<BindPath> BindPaths { get; private set; }
 
         /// <summary>
         /// Gets the list of target bindpaths.
         /// </summary>
-        public List<BindPath> TargetBindPaths { get; private set; }
+        //public List<BindPath> TargetBindPaths { get; private set; }
 
         /// <summary>
         /// Gets the list of updated bindpaths.
         /// </summary>
-        public List<BindPath> UpdatedBindPaths { get; private set; }
+        //public List<BindPath> UpdatedBindPaths { get; private set; }
 
         /// <summary>
         /// Gets or sets the option to enable building binary delta patches.
@@ -132,17 +99,17 @@ namespace WixToolset
         /// Gets or sets the default compression level to use for cabinets
         /// that don't have their compression level explicitly set.
         /// </summary>
-        public CompressionLevel DefaultCompressionLevel { get; set; }
+        //public CompressionLevel DefaultCompressionLevel { get; set; }
 
         /// <summary>
         /// Gets and sets the location to save the WixPdb.
         /// </summary>
         /// <value>The location in which to save the WixPdb. Null if the the WixPdb should not be output.</value>
-        public string PdbFile { get; set; }
+        //public string PdbFile { get; set; }
 
-        public List<string> Ices { get; private set; }
+        //public List<string> Ices { get; private set; }
 
-        public List<string> SuppressIces { get; private set; }
+        //public List<string> SuppressIces { get; private set; }
 
         /// <summary>
         /// Gets and sets the option to suppress resetting ACLs by the binder.
@@ -185,24 +152,164 @@ namespace WixToolset
         /// Gets or sets the Wix variable resolver.
         /// </summary>
         /// <value>The Wix variable resolver.</value>
-        public WixVariableResolver WixVariableResolver { get; set; }
+        internal WixVariableResolver WixVariableResolver { get; set; }
 
         /// <summary>
         /// Add a binder extension.
         /// </summary>
         /// <param name="extension">New extension.</param>
-        public void AddExtension(IBinderExtension extension)
-        {
-            this.extensions.Add(extension);
-        }
+        //public void AddExtension(IBinderExtension extension)
+        //{
+        //    this.extensions.Add(extension);
+        //}
 
         /// <summary>
         /// Add a file manager extension.
         /// </summary>
         /// <param name="extension">New file manager.</param>
-        public void AddExtension(IBinderFileManager extension)
+        //public void AddExtension(IBinderFileManager extension)
+        //{
+        //    this.fileManagers.Add(extension);
+        //}
+
+        public bool Bind()
+        {
+            //if (!String.IsNullOrEmpty(this.Context.FileManagerCore.CabCachePath))
+            //{
+            //    Directory.CreateDirectory(this.Context.FileManagerCore.CabCachePath);
+            //}
+
+            //this.core = new BinderCore();
+            //this.core.FileManagerCore = this.Context.FileManagerCore;
+
+            this.WriteBuildInfoTable(this.Context.IntermediateRepresentation, this.Context.OutputPath);
+
+            // Prebind.
+            //
+            this.Context.Extensions = this.Context.ExtensionManager.Create<IBinderExtension>();
+
+            foreach (IBinderExtension extension in this.Context.Extensions)
+            {
+                extension.PreBind(this.Context);
+            }
+
+            // Resolve.
+            //
+            var resolveResult = this.Resolve();
+
+            this.Context.DelayedFields = resolveResult.DelayedFields;
+
+            this.Context.ExpectedEmbeddedFiles = resolveResult.ExpectedEmbeddedFiles;
+
+            // Backend.
+            //
+            var bindResult = this.BackendBind();
+
+            if (bindResult != null)
+            {
+                // Postbind.
+                //
+                foreach (IBinderExtension extension in this.Context.Extensions)
+                {
+                    extension.PostBind(bindResult);
+                }
+
+                // Layout.
+                //
+                this.Layout(bindResult);
+            }
+
+            return Messaging.Instance.EncounteredError;
+        }
+
+        private ResolveResult Resolve()
+        {
+            var buildingPatch = (this.Context.IntermediateRepresentation.Type == OutputType.Patch);
+
+            var filesWithEmbeddedFiles = new ExtractEmbeddedFiles();
+
+            IEnumerable<DelayedField> delayedFields;
+            {
+                var command = new ResolveFieldsCommand();
+                command.BuildingPatch = buildingPatch;
+                command.BindVariableResolver = this.Context.WixVariableResolver;
+                command.BindPaths = this.Context.BindPaths;
+                command.Extensions = this.Context.Extensions;
+                command.FilesWithEmbeddedFiles = filesWithEmbeddedFiles;
+                command.IntermediateFolder = this.Context.IntermediateFolder;
+                command.Tables = this.Context.IntermediateRepresentation.Tables;
+                command.SupportDelayedResolution = true;
+                command.Execute();
+
+                delayedFields = command.DelayedFields;
+            }
+
+            if (this.Context.IntermediateRepresentation.SubStorages != null)
+            {
+                foreach (SubStorage transform in this.Context.IntermediateRepresentation.SubStorages)
+                {
+                    var command = new ResolveFieldsCommand();
+                    command.BuildingPatch = buildingPatch;
+                    command.BindVariableResolver = this.Context.WixVariableResolver;
+                    command.BindPaths = this.Context.BindPaths;
+                    command.Extensions = this.Context.Extensions;
+                    command.FilesWithEmbeddedFiles = filesWithEmbeddedFiles;
+                    command.IntermediateFolder = this.Context.IntermediateFolder;
+                    command.Tables = transform.Data.Tables;
+                    command.SupportDelayedResolution = false;
+                    command.Execute();
+                }
+            }
+
+            var expectedEmbeddedFiles = filesWithEmbeddedFiles.GetExpectedEmbeddedFiles();
+
+            return new ResolveResult
+            {
+                ExpectedEmbeddedFiles = expectedEmbeddedFiles,
+                DelayedFields = delayedFields,
+            };
+        }
+
+        private BindResult BackendBind()
+        {
+            var backendFactories = this.Context.ExtensionManager.Create<IBackendFactory>();
+
+            foreach (var factory in backendFactories)
+            {
+                if (factory.TryCreateBackend(this.Context.IntermediateRepresentation.Type.ToString(), this.Context.OutputPath, null, out var backend))
+                {
+                    var result = backend.Bind(this.Context);
+                    return result;
+                }
+            }
+
+            // TODO: messaging that a backend could not be found to bind the output type?
+
+            return null;
+        }
+        private void Layout(BindResult result)
         {
-            this.fileManagers.Add(extension);
+            try
+            {
+                this.LayoutMedia(result.FileTransfers);
+            }
+            finally
+            {
+                if (!String.IsNullOrEmpty(this.Context.ContentsFile) && result.ContentFilePaths != null)
+                {
+                    this.CreateContentsFile(this.Context.ContentsFile, result.ContentFilePaths);
+                }
+
+                if (!String.IsNullOrEmpty(this.Context.OutputsFile) && result.FileTransfers != null)
+                {
+                    this.CreateOutputsFile(this.Context.OutputsFile, result.FileTransfers, this.Context.OutputPdbPath);
+                }
+
+                if (!String.IsNullOrEmpty(this.Context.BuiltOutputsFile) && result.FileTransfers != null)
+                {
+                    this.CreateBuiltOutputsFile(this.Context.BuiltOutputsFile, result.FileTransfers, this.Context.OutputPdbPath);
+                }
+            }
         }
 
         /// <summary>
@@ -212,6 +319,7 @@ namespace WixToolset
         /// <param name="file">The Windows Installer file to create.</param>
         /// <remarks>The Binder.DeleteTempFiles method should be called after calling this method.</remarks>
         /// <returns>true if binding completed successfully; false otherwise</returns>
+#if false
         public bool Bind(Output output, string file)
         {
             // Ensure the cabinet cache path exists if we are going to use it.
@@ -220,20 +328,20 @@ namespace WixToolset
                 Directory.CreateDirectory(this.CabCachePath);
             }
 
-            this.fileManagerCore = new BinderFileManagerCore();
-            this.fileManagerCore.CabCachePath = this.CabCachePath;
-            this.fileManagerCore.Output = output;
-            this.fileManagerCore.TempFilesLocation = this.TempFilesLocation;
-            this.fileManagerCore.AddBindPaths(this.BindPaths, BindStage.Normal);
-            this.fileManagerCore.AddBindPaths(this.TargetBindPaths, BindStage.Target);
-            this.fileManagerCore.AddBindPaths(this.UpdatedBindPaths, BindStage.Updated);
-            foreach (IBinderFileManager fileManager in this.fileManagers)
-            {
-                fileManager.Core = this.fileManagerCore;
-            }
+            //var fileManagerCore = new BinderFileManagerCore();
+            //fileManagerCore.CabCachePath = this.CabCachePath;
+            //fileManagerCore.Output = output;
+            //fileManagerCore.TempFilesLocation = this.TempFilesLocation;
+            //fileManagerCore.AddBindPaths(this.BindPaths, BindStage.Normal);
+            //fileManagerCore.AddBindPaths(this.TargetBindPaths, BindStage.Target);
+            //fileManagerCore.AddBindPaths(this.UpdatedBindPaths, BindStage.Updated);
+            //foreach (IBinderFileManager fileManager in this.fileManagers)
+            //{
+            //    fileManager.Core = fileManagerCore;
+            //}
 
             this.core = new BinderCore();
-            this.core.FileManagerCore = this.fileManagerCore;
+            this.core.FileManagerCore = fileManagerCore;
 
             this.WriteBuildInfoTable(output, file);
 
@@ -246,54 +354,69 @@ namespace WixToolset
             }
 
             // Gather all the wix variables.
-            Table wixVariableTable = output.Tables["WixVariable"];
-            if (null != wixVariableTable)
+            //Table wixVariableTable = output.Tables["WixVariable"];
+            //if (null != wixVariableTable)
+            //{
+            //    foreach (WixVariableRow wixVariableRow in wixVariableTable.Rows)
+            //    {
+            //        this.WixVariableResolver.AddVariable(wixVariableRow);
+            //    }
+            //}
+
+            //BindContext context = new BindContext();
+            //context.CabbingThreadCount = this.CabbingThreadCount;
+            //context.DefaultCompressionLevel = this.DefaultCompressionLevel;
+            //context.Extensions = this.extensions;
+            //context.FileManagerCore = fileManagerCore;
+            //context.FileManagers = this.fileManagers;
+            //context.Ices = this.Ices;
+            //context.IntermediateFolder = this.TempFilesLocation;
+            //context.IntermediateRepresentation = output;
+            //context.Localizer = this.Localizer;
+            //context.OutputPath = file;
+            //context.OutputPdbPath = this.PdbFile;
+            //context.SuppressIces = this.SuppressIces;
+            //context.SuppressValidation = this.SuppressValidation;
+            //context.WixVariableResolver = this.WixVariableResolver;
+
+            BindResult result = null;
+
+            foreach (var factory in this.BackendFactories)
             {
-                foreach (WixVariableRow wixVariableRow in wixVariableTable.Rows)
+                if (factory.TryCreateBackend(output.Type.ToString(), file, null, out var backend))
                 {
-                    this.WixVariableResolver.AddVariable(wixVariableRow);
+                    result = backend.Bind(context);
+                    break;
                 }
             }
 
-            IEnumerable<FileTransfer> fileTransfers = null;
-            IEnumerable<string> contentPaths = null;
-
-            switch (output.Type)
+            if (result == null)
             {
-                case OutputType.Bundle:
-                    this.BindBundle(output, file, out fileTransfers, out contentPaths);
-                    break;
-
-                case OutputType.Transform:
-                    this.BindTransform(output, file);
-                    break;
+                // TODO: messaging that a backend could not be found to bind the output type?
 
-                default:
-                    this.BindDatabase(output, file, out fileTransfers, out contentPaths);
-                    break;
+                return false;
             }
 
-
             // Layout media
             try
             {
-                this.LayoutMedia(fileTransfers);
+                this.LayoutMedia(result.FileTransfers);
             }
             finally
             {
-                if (!String.IsNullOrEmpty(this.ContentsFile) && contentPaths != null)
+                if (!String.IsNullOrEmpty(this.ContentsFile) && result.ContentFilePaths != null)
                 {
-                    this.CreateContentsFile(this.ContentsFile, contentPaths);
+                    this.CreateContentsFile(this.ContentsFile, result.ContentFilePaths);
                 }
 
-                if (!String.IsNullOrEmpty(this.OutputsFile) && fileTransfers != null)
+                if (!String.IsNullOrEmpty(this.OutputsFile) && result.FileTransfers != null)
                 {
-                    this.CreateOutputsFile(this.OutputsFile, fileTransfers, this.PdbFile);
+                    this.CreateOutputsFile(this.OutputsFile, result.FileTransfers, this.PdbFile);
                 }
 
-                if (!String.IsNullOrEmpty(this.BuiltOutputsFile) && fileTransfers != null)
+                if (!String.IsNullOrEmpty(this.BuiltOutputsFile) && result.FileTransfers != null)
                 {
-                    this.CreateBuiltOutputsFile(this.BuiltOutputsFile, fileTransfers, this.PdbFile);
+                    this.CreateBuiltOutputsFile(this.BuiltOutputsFile, result.FileTransfers, this.PdbFile);
                 }
             }
 
@@ -301,6 +424,7 @@ namespace WixToolset
 
             return Messaging.Instance.EncounteredError;
         }
+#endif
 
         /// <summary>
         /// Does any housekeeping after Bind.
@@ -312,12 +436,12 @@ namespace WixToolset
             {
                 if (!this.DeleteTempFiles())
                 {
-                    this.core.OnMessage(WixWarnings.FailedToDeleteTempDir(this.TempFilesLocation));
+                    this.Context.Messaging.OnMessage(WixWarnings.FailedToDeleteTempDir(this.TempFilesLocation));
                 }
             }
             else
             {
-                this.core.OnMessage(WixVerboses.BinderTempDirLocatedAt(this.TempFilesLocation));
+                this.Context.Messaging.OnMessage(WixVerboses.BinderTempDirLocatedAt(this.TempFilesLocation));
             }
         }
 
@@ -327,7 +451,7 @@ namespace WixToolset
         /// <returns>True if all files were deleted, false otherwise.</returns>
         private bool DeleteTempFiles()
         {
-            bool deleted = Common.DeleteTempFiles(this.TempFilesLocation, this.core);
+            bool deleted = Common.DeleteTempFiles(this.TempFilesLocation, this.Context.Messaging);
             return deleted;
         }
 
@@ -338,7 +462,7 @@ namespace WixToolset
         /// <param name="databaseFile">The output file if OutputFile not set.</param>
         private void WriteBuildInfoTable(Output output, string outputFile)
         {
-            Table buildInfoTable = output.EnsureTable(this.core.TableDefinitions["WixBuildInfo"]);
+            Table buildInfoTable = output.EnsureTable(this.TableDefinitions["WixBuildInfo"]);
             Row buildInfoRow = buildInfoTable.CreateRow(null);
 
             Assembly executingAssembly = Assembly.GetExecutingAssembly();
@@ -346,17 +470,18 @@ namespace WixToolset
             buildInfoRow[0] = fileVersion.FileVersion;
             buildInfoRow[1] = outputFile;
 
-            if (!String.IsNullOrEmpty(this.WixprojectFile))
+            if (!String.IsNullOrEmpty(this.Context.WixprojectFile))
             {
-                buildInfoRow[2] = this.WixprojectFile;
+                buildInfoRow[2] = this.Context.WixprojectFile;
             }
 
-            if (!String.IsNullOrEmpty(this.PdbFile))
+            if (!String.IsNullOrEmpty(this.Context.OutputPdbPath))
             {
-                buildInfoRow[3] = this.PdbFile;
+                buildInfoRow[3] = this.Context.OutputPdbPath;
             }
         }
 
+#if DELETE_THIS_CODE
         /// <summary>
         /// Binds a bundle.
         /// </summary>
@@ -454,6 +579,7 @@ namespace WixToolset
             command.OutputPath = outputPath;
             command.Execute();
         }
+#endif
 
         /// <summary>
         /// Final step in binding that transfers (moves/copies) all files generated into the appropriate
@@ -464,12 +590,9 @@ namespace WixToolset
         {
             if (null != transfers && transfers.Any())
             {
-                this.core.OnMessage(WixVerboses.LayingOutMedia());
+                this.Context.Messaging.OnMessage(WixVerboses.LayingOutMedia());
 
-                TransferFilesCommand command = new TransferFilesCommand();
-                command.FileManagers = this.fileManagers;
-                command.FileTransfers = transfers;
-                command.SuppressAclReset = this.SuppressAclReset;
+                var command = new TransferFilesCommand(this.Context.BindPaths, this.Context.Extensions, transfers, this.Context.SuppressAclReset);
                 command.Execute();
             }
         }
@@ -482,7 +605,7 @@ namespace WixToolset
         /// <param name="directory">Directory identifier.</param>
         /// <param name="canonicalize">Canonicalize the path for standard directories.</param>
         /// <returns>Source path of a directory.</returns>
-        internal static string GetDirectoryPath(Hashtable directories, Hashtable componentIdGenSeeds, string directory, bool canonicalize)
+        public static string GetDirectoryPath(Hashtable directories, Hashtable componentIdGenSeeds, string directory, bool canonicalize)
         {
             if (!directories.Contains(directory))
             {
@@ -543,9 +666,9 @@ namespace WixToolset
         /// <param name="compressed">Specifies the package is compressed.</param>
         /// <param name="useLongName">Specifies the package uses long file names.</param>
         /// <returns>Source path of file relative to package directory.</returns>
-        internal static string GetFileSourcePath(Hashtable directories, string directoryId, string fileName, bool compressed, bool useLongName)
+        public static string GetFileSourcePath(Hashtable directories, string directoryId, string fileName, bool compressed, bool useLongName)
         {
-            string fileSourcePath = Installer.GetName(fileName, true, useLongName);
+            string fileSourcePath = Common.GetName(fileName, true, useLongName);
 
             if (compressed)
             {
diff --git a/src/WixToolset.Core/BinderFileManager.cs b/src/WixToolset.Core/BinderFileManager.cs
index 0da54002..1527d93d 100644
--- a/src/WixToolset.Core/BinderFileManager.cs
+++ b/src/WixToolset.Core/BinderFileManager.cs
@@ -12,6 +12,7 @@ namespace WixToolset
     using WixToolset.Data.Rows;
     using WixToolset.Extensibility;
 
+#if false
     /// <summary>
     /// Base class for creating a binder file manager.
     /// </summary>
@@ -367,4 +368,5 @@ namespace WixToolset
         [DllImport("Kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
         private static extern bool CreateHardLink(string lpFileName, string lpExistingFileName, IntPtr lpSecurityAttributes);
     }
+#endif
 }
diff --git a/src/WixToolset.Core/BinderFileManagerCore.cs b/src/WixToolset.Core/BinderFileManagerCore.cs
index 6a5e1d5e..f1a78880 100644
--- a/src/WixToolset.Core/BinderFileManagerCore.cs
+++ b/src/WixToolset.Core/BinderFileManagerCore.cs
@@ -6,6 +6,7 @@ namespace WixToolset
     using System.Collections.Generic;
     using System.Linq;
     using WixToolset.Data;
+    using WixToolset.Data.Bind;
     using WixToolset.Extensibility;
 
     public class BinderFileManagerCore : IBinderFileManagerCore
diff --git a/src/WixToolset.Core/Cab/CabinetFileInfo.cs b/src/WixToolset.Core/Cab/CabinetFileInfo.cs
index 849bb3bb..816f9e3e 100644
--- a/src/WixToolset.Core/Cab/CabinetFileInfo.cs
+++ b/src/WixToolset.Core/Cab/CabinetFileInfo.cs
@@ -1,19 +1,12 @@
 // 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
+namespace WixToolset.Core.Cab
 {
-    using System;
-
     /// <summary>
     /// Properties of a file in a cabinet.
     /// </summary>
-    internal sealed class CabinetFileInfo
+    public sealed class CabinetFileInfo
     {
-        private string fileId;
-        private ushort date;
-        private ushort time;
-        private int size;
-
         /// <summary>
         /// Constructs CabinetFileInfo
         /// </summary>
@@ -22,43 +15,31 @@ namespace WixToolset
         /// <param name="time">Last modified time (MS-DOS time)</param>
         public CabinetFileInfo(string fileId, ushort date, ushort time, int size)
         {
-            this.fileId = fileId;
-            this.date = date;
-            this.time = time;
-            this.size = size;
+            this.FileId = fileId;
+            this.Date = date;
+            this.Time = time;
+            this.Size = size;
         }
 
         /// <summary>
         /// Gets the file Id of the file.
         /// </summary>
         /// <value>file Id</value>
-        public string FileId
-        {
-            get { return this.fileId; }
-        }
+        public string FileId { get; }
 
         /// <summary>
         /// Gets modified date (DOS format).
         /// </summary>
-        public ushort Date
-        {
-            get { return this.date; }
-        }
+        public ushort Date { get; }
 
         /// <summary>
         /// Gets modified time (DOS format).
         /// </summary>
-        public ushort Time
-        {
-            get { return this.time; }
-        }
+        public ushort Time { get; }
 
         /// <summary>
         /// Gets the size of the file in bytes.
         /// </summary>
-        public int Size
-        {
-            get { return this.size; }
-        }
+        public int Size { get; }
     }
 }
diff --git a/src/WixToolset.Core/Cab/WixCreateCab.cs b/src/WixToolset.Core/Cab/WixCreateCab.cs
index 8f985a43..4ebdd1c0 100644
--- a/src/WixToolset.Core/Cab/WixCreateCab.cs
+++ b/src/WixToolset.Core/Cab/WixCreateCab.cs
@@ -1,12 +1,12 @@
 // 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.Cab
+namespace WixToolset.Core.Cab
 {
     using System;
     using System.Globalization;
     using System.IO;
     using System.Runtime.InteropServices;
-    using WixToolset.Bind.Databases;
+    using WixToolset.Core.Bind;
     using WixToolset.Core.Native;
     using WixToolset.Data;
 
diff --git a/src/WixToolset.Core/Cab/WixEnumerateCab.cs b/src/WixToolset.Core/Cab/WixEnumerateCab.cs
index 017eeffb..0b4055d6 100644
--- a/src/WixToolset.Core/Cab/WixEnumerateCab.cs
+++ b/src/WixToolset.Core/Cab/WixEnumerateCab.cs
@@ -1,6 +1,6 @@
 // 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.Cab
+namespace WixToolset.Core.Cab
 {
     using System;
     using System.Collections.Generic;
@@ -10,7 +10,7 @@ namespace WixToolset.Cab
     /// <summary>
     /// Wrapper class around interop with wixcab.dll to enumerate files from a cabinet.
     /// </summary>
-    internal sealed class WixEnumerateCab : IDisposable
+    public sealed class WixEnumerateCab : IDisposable
     {
         private bool disposed;
         private List<CabinetFileInfo> fileInfoList;
@@ -38,7 +38,7 @@ namespace WixToolset.Cab
         /// </summary>
         /// <param name="cabinetFile">path to cabinet</param>
         /// <returns>list of CabinetFileInfo</returns>
-        internal List<CabinetFileInfo> Enumerate(string cabinetFile)
+        public List<CabinetFileInfo> Enumerate(string cabinetFile)
         {
             this.fileInfoList = new List<CabinetFileInfo>();
 
diff --git a/src/WixToolset.Core/Cab/WixExtractCab.cs b/src/WixToolset.Core/Cab/WixExtractCab.cs
index debdaf15..e776b08e 100644
--- a/src/WixToolset.Core/Cab/WixExtractCab.cs
+++ b/src/WixToolset.Core/Cab/WixExtractCab.cs
@@ -1,9 +1,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.
 
-namespace WixToolset.Cab
+namespace WixToolset.Core.Cab
 {
     using System;
-    using System.Runtime.InteropServices;
     using WixToolset.Core.Native;
 
     /// <summary>
diff --git a/src/WixToolset.Core/CommandLine/BuildCommand.cs b/src/WixToolset.Core/CommandLine/BuildCommand.cs
index afb9e829..32da5bcf 100644
--- a/src/WixToolset.Core/CommandLine/BuildCommand.cs
+++ b/src/WixToolset.Core/CommandLine/BuildCommand.cs
@@ -7,13 +7,14 @@ namespace WixToolset.Core
     using System.IO;
     using System.Linq;
     using WixToolset.Data;
+    using WixToolset.Data.Rows;
     using WixToolset.Extensibility;
 
     internal class BuildCommand : ICommandLineCommand
     {
-        public BuildCommand(ExtensionManager extensions, IEnumerable<SourceFile> sources, IDictionary<string, string> preprocessorVariables, IEnumerable<string> locFiles, IEnumerable<string> libraryFiles, string outputPath, OutputType outputType, IEnumerable<string> cultures, bool bindFiles, IEnumerable<BindPath> bindPaths, string intermediateFolder, string contentsFile, string outputsFile, string builtOutputsFile, string wixProjectFile)
+        public BuildCommand(ExtensionManager extensions, IEnumerable<SourceFile> sources, IDictionary<string, string> preprocessorVariables, IEnumerable<string> locFiles, IEnumerable<string> libraryFiles, string outputPath, OutputType outputType, string cabCachePath, IEnumerable<string> cultures, bool bindFiles, IEnumerable<BindPath> bindPaths, string intermediateFolder, string contentsFile, string outputsFile, string builtOutputsFile, string wixProjectFile)
         {
-            this.Extensions = extensions;
+            this.ExtensionManager = extensions;
             this.LocFiles = locFiles;
             this.LibraryFiles = libraryFiles;
             this.PreprocessorVariables = preprocessorVariables;
@@ -21,6 +22,7 @@ namespace WixToolset.Core
             this.OutputPath = outputPath;
             this.OutputType = outputType;
 
+            this.CabCachePath = cabCachePath;
             this.Cultures = cultures;
             this.BindFiles = bindFiles;
             this.BindPaths = bindPaths;
@@ -32,7 +34,7 @@ namespace WixToolset.Core
             this.WixProjectFile = wixProjectFile;
         }
 
-        public ExtensionManager Extensions { get; }
+        public ExtensionManager ExtensionManager { get; }
 
         public IEnumerable<string> LocFiles { get; }
 
@@ -46,6 +48,8 @@ namespace WixToolset.Core
 
         private OutputType OutputType { get; }
 
+        public string CabCachePath { get; }
+
         public IEnumerable<string> Cultures { get; }
 
         public bool BindFiles { get; }
@@ -70,7 +74,9 @@ namespace WixToolset.Core
 
             if (this.OutputType == OutputType.Library)
             {
-                this.LibraryPhase(intermediates, tableDefinitions);
+                var library = this.LibraryPhase(intermediates, tableDefinitions);
+
+                library?.Save(this.OutputPath);
             }
             else
             {
@@ -105,51 +111,40 @@ namespace WixToolset.Core
             return intermediates;
         }
 
-        private void LibraryPhase(IEnumerable<Intermediate> intermediates, TableDefinitionCollection tableDefinitions)
+        private Library LibraryPhase(IEnumerable<Intermediate> intermediates, TableDefinitionCollection tableDefinitions)
         {
             var localizations = this.LoadLocalizationFiles(tableDefinitions).ToList();
 
             // If there was an error adding localization files, then bail.
             if (Messaging.Instance.EncounteredError)
             {
-                return;
+                return null;
             }
 
-            var sections = intermediates.SelectMany(i => i.Sections).ToList();
-
-            LibraryBinaryFileResolver resolver = null;
-
-            if (this.BindFiles)
-            {
-                resolver = new LibraryBinaryFileResolver();
-                resolver.FileManagers = new List<IBinderFileManager> { new BinderFileManager() }; ;
-                resolver.VariableResolver = new WixVariableResolver();
-
-                BinderFileManagerCore core = new BinderFileManagerCore();
-                core.AddBindPaths(this.BindPaths, BindStage.Normal);
-
-                foreach (var fileManager in resolver.FileManagers)
-                {
-                    fileManager.Core = core;
-                }
-            }
+            var resolver = CreateWixResolverWithVariables(null, null);
 
-            var librarian = new Librarian();
+            var context = new LibraryContext();
+            context.BindFiles = this.BindFiles;
+            context.BindPaths = this.BindPaths;
+            context.Extensions = this.ExtensionManager.Create<ILibrarianExtension>();
+            context.Localizations = localizations;
+            context.Sections = intermediates.SelectMany(i => i.Sections).ToList();
+            context.WixVariableResolver = resolver;
 
-            var library = librarian.Combine(sections, localizations, resolver);
+            var librarian = new Librarian(context);
 
-            library?.Save(this.OutputPath);
+            return librarian.Combine();
         }
 
         private Output LinkPhase(IEnumerable<Intermediate> intermediates, TableDefinitionCollection tableDefinitions)
         {
             var sections = intermediates.SelectMany(i => i.Sections).ToList();
 
-            sections.AddRange(SectionsFromLibraries(tableDefinitions));
+            sections.AddRange(this.SectionsFromLibraries(tableDefinitions));
 
             var linker = new Linker();
 
-            foreach (var data in this.Extensions.Create<IExtensionData>())
+            foreach (var data in this.ExtensionManager.Create<IExtensionData>())
             {
                 linker.AddExtensionData(data);
             }
@@ -159,6 +154,40 @@ namespace WixToolset.Core
             return output;
         }
 
+        private void BindPhase(Output output, TableDefinitionCollection tableDefinitions)
+        {
+            var localizations = this.LoadLocalizationFiles(tableDefinitions).ToList();
+
+            var localizer = new Localizer(localizations);
+
+            var resolver = CreateWixResolverWithVariables(localizer, output);
+
+            var context = new BindContext();
+            context.Messaging = Messaging.Instance;
+            context.ExtensionManager = this.ExtensionManager;
+            context.BindPaths = this.BindPaths ?? Array.Empty<BindPath>();
+            //context.CabbingThreadCount = this.CabbingThreadCount;
+            context.CabCachePath = this.CabCachePath;
+            context.Codepage = localizer.Codepage;
+            //context.DefaultCompressionLevel = this.DefaultCompressionLevel;
+            //context.Ices = this.Ices;
+            context.IntermediateFolder = this.IntermediateFolder;
+            context.IntermediateRepresentation = output;
+            context.OutputPath = this.OutputPath;
+            context.OutputPdbPath = Path.ChangeExtension(this.OutputPath, ".wixpdb");
+            //context.SuppressIces = this.SuppressIces;
+            context.SuppressValidation = true;
+            //context.SuppressValidation = this.SuppressValidation;
+            context.WixVariableResolver = resolver;
+            context.ContentsFile = this.ContentsFile;
+            context.OutputsFile = this.OutputsFile;
+            context.BuiltOutputsFile = this.BuiltOutputsFile;
+            context.WixprojectFile = this.WixProjectFile;
+
+            var binder = new Binder(context);
+            binder.Bind();
+        }
+
         private IEnumerable<Section> SectionsFromLibraries(TableDefinitionCollection tableDefinitions)
         {
             var sections = new List<Section>();
@@ -187,34 +216,6 @@ namespace WixToolset.Core
             return sections;
         }
 
-        private void BindPhase(Output output, TableDefinitionCollection tableDefinitions)
-        {
-            var localizations = this.LoadLocalizationFiles(tableDefinitions).ToList();
-
-            var localizer = new Localizer(localizations);
-
-            var resolver = new WixVariableResolver(localizer);
-
-            var binder = new Binder();
-            binder.TempFilesLocation = this.IntermediateFolder;
-            binder.WixVariableResolver = resolver;
-            binder.SuppressValidation = true;
-
-            binder.ContentsFile = this.ContentsFile;
-            binder.OutputsFile = this.OutputsFile;
-            binder.BuiltOutputsFile = this.BuiltOutputsFile;
-            binder.WixprojectFile = this.WixProjectFile;
-
-            if (this.BindPaths != null)
-            {
-                binder.BindPaths.AddRange(this.BindPaths);
-            }
-
-            binder.AddExtension(new BinderFileManager());
-
-            binder.Bind(output, this.OutputPath);
-        }
-
         private IEnumerable<Localization> LoadLocalizationFiles(TableDefinitionCollection tableDefinitions)
         {
             foreach (var loc in this.LocFiles)
@@ -225,30 +226,21 @@ namespace WixToolset.Core
             }
         }
 
-        /// <summary>
-        /// File resolution mechanism to create binary library.
-        /// </summary>
-        private class LibraryBinaryFileResolver : ILibraryBinaryFileResolver
+        private static WixVariableResolver CreateWixResolverWithVariables(Localizer localizer, Output output)
         {
-            public IEnumerable<IBinderFileManager> FileManagers { get; set; }
-
-            public WixVariableResolver VariableResolver { get; set; }
+            var resolver = new WixVariableResolver(localizer);
 
-            public string Resolve(SourceLineNumber sourceLineNumber, string table, string path)
+            // Gather all the wix variables.
+            Table wixVariableTable = output?.Tables["WixVariable"];
+            if (null != wixVariableTable)
             {
-                string resolvedPath = this.VariableResolver.ResolveVariables(sourceLineNumber, path, false);
-
-                foreach (IBinderFileManager fileManager in this.FileManagers)
+                foreach (WixVariableRow wixVariableRow in wixVariableTable.Rows)
                 {
-                    string finalPath = fileManager.ResolveFile(resolvedPath, table, sourceLineNumber, BindStage.Normal);
-                    if (!String.IsNullOrEmpty(finalPath))
-                    {
-                        return finalPath;
-                    }
+                    resolver.AddVariable(wixVariableRow);
                 }
-
-                return null;
             }
+
+            return resolver;
         }
     }
 }
diff --git a/src/WixToolset.Core/CommandLine/CommandLine.cs b/src/WixToolset.Core/CommandLine/CommandLine.cs
index a3a6831c..2f203ecb 100644
--- a/src/WixToolset.Core/CommandLine/CommandLine.cs
+++ b/src/WixToolset.Core/CommandLine/CommandLine.cs
@@ -6,6 +6,7 @@ namespace WixToolset.Core
     using System.Collections.Generic;
     using System.IO;
     using System.Linq;
+    using System.Reflection;
     using System.Text;
     using System.Text.RegularExpressions;
     using WixToolset.Data;
@@ -71,6 +72,7 @@ namespace WixToolset.Core
 
             var intermediateFolder = String.Empty;
 
+            var cabCachePath = String.Empty;
             var cultures = new List<string>();
             var contentsFile = String.Empty;
             var outputsFile = String.Empty;
@@ -98,6 +100,10 @@ namespace WixToolset.Core
                             cmdline.GetNextArgumentOrError(bindPaths);
                             return true;
 
+                        case "cc":
+                            cmdline.GetNextArgumentOrError(ref cabCachePath);
+                            return true;
+                            
                         case "cultures":
                             cmdline.GetNextArgumentOrError(cultures);
                             return true;
@@ -190,12 +196,14 @@ namespace WixToolset.Core
             {
                 case Commands.Build:
                     {
+                        LoadStandardBackends(cli.ExtensionManager);
+
                         var sourceFiles = GatherSourceFiles(files, outputFolder);
                         var variables = GatherPreprocessorVariables(defines);
                         var bindPathList = GatherBindPaths(bindPaths);
                         var extensions = cli.ExtensionManager;
                         var type = CalculateOutputType(outputType, outputFile);
-                        return new BuildCommand(extensions, sourceFiles, variables, locFiles, libraryFiles, outputFile, type, cultures, bindFiles, bindPathList, intermediateFolder, contentsFile, outputsFile, builtOutputsFile, wixProjectFile);
+                        return new BuildCommand(extensions, sourceFiles, variables, locFiles, libraryFiles, outputFile, type, cabCachePath, cultures, bindFiles, bindPathList, intermediateFolder, contentsFile, outputsFile, builtOutputsFile, wixProjectFile);
                     }
 
                 case Commands.Compile:
@@ -209,6 +217,18 @@ namespace WixToolset.Core
             return null;
         }
 
+        private static void LoadStandardBackends(ExtensionManager extensionManager)
+        {
+            var folder = Path.GetDirectoryName(new Uri(Assembly.GetExecutingAssembly().CodeBase).LocalPath);
+
+            foreach (var backendAssemblyName in new[] { "WixToolset.Core.Burn.dll", "WixToolset.Core.WindowsInstaller.dll" })
+            {
+                var path = Path.Combine(folder, backendAssemblyName);
+
+                extensionManager.Load(path);
+            }
+        }
+
         private static OutputType CalculateOutputType(string outputType, string outputFile)
         {
             if (String.IsNullOrEmpty(outputType))
diff --git a/src/WixToolset.Core/Common.cs b/src/WixToolset.Core/Common.cs
index a2881984..28e7ee7b 100644
--- a/src/WixToolset.Core/Common.cs
+++ b/src/WixToolset.Core/Common.cs
@@ -17,7 +17,7 @@ namespace WixToolset
     /// <summary>
     /// Common Wix utility methods and types.
     /// </summary>
-    internal static class Common
+    public static class Common
     {
         //-------------------------------------------------------------------------------------------------
         // Layout of an Access Mask (from http://technet.microsoft.com/en-us/library/cc783530(WS.10).aspx)
@@ -89,9 +89,7 @@ namespace WixToolset
         // FILE_ALL_ACCESS           (STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | 0x1FF)
         internal static readonly string[] FilePermissions = { "Read", "Write", "Append", "ReadExtendedAttributes", "WriteExtendedAttributes", "Execute", "FileAllRights", "ReadAttributes", "WriteAttributes" };
 
-        internal static readonly string[] ReservedFileNames = { "CON", "PRN", "AUX", "NUL", "COM1", "COM2", "COM3", "COM4", "COM5", "COM6", "COM7", "COM8", "COM9", "LPT1", "LPT2", "LPT3", "LPT4", "LPT5", "LPT6", "LPT7", "LPT8", "LPT9" };
-
-        internal static readonly Regex WixVariableRegex = new Regex(@"(\!|\$)\((?<namespace>loc|wix|bind|bindpath)\.(?<fullname>(?<name>[_A-Za-z][0-9A-Za-z_]+)(\.(?<scope>[_A-Za-z][0-9A-Za-z_\.]*))?)(\=(?<value>.+?))?\)", RegexOptions.Compiled | RegexOptions.Singleline | RegexOptions.ExplicitCapture);
+        public static readonly Regex WixVariableRegex = new Regex(@"(\!|\$)\((?<namespace>loc|wix|bind|bindpath)\.(?<fullname>(?<name>[_A-Za-z][0-9A-Za-z_]+)(\.(?<scope>[_A-Za-z][0-9A-Za-z_\.]*))?)(\=(?<value>.+?))?\)", RegexOptions.Compiled | RegexOptions.Singleline | RegexOptions.ExplicitCapture);
 
         internal const char CustomRowFieldSeparator = '\x85';
 
@@ -170,15 +168,14 @@ namespace WixToolset
         /// <exception cref="ArgumentNullException"><paramref name="value"/> is null.</exception>
         /// <exception cref="NotSupportedException">The value doesn't not represent a valid code page name or integer value.</exception>
         /// <exception cref="WixException">The code page is invalid for summary information.</exception>
-        internal static int GetValidCodePage(string value, bool allowNoChange = false, bool onlyAnsi = false, SourceLineNumber sourceLineNumbers = null)
+        public static int GetValidCodePage(string value, bool allowNoChange = false, bool onlyAnsi = false, SourceLineNumber sourceLineNumbers = null)
         {
-            int codePage;
-            Encoding encoding;
-
             try
             {
+                Encoding encoding;
+
                 // check if a integer as a string was passed
-                if (Int32.TryParse(value, out codePage))
+                if (Int32.TryParse(value, out int codePage))
                 {
                     if (0 == codePage)
                     {
@@ -366,9 +363,9 @@ namespace WixToolset
         /// Generate a new Windows Installer-friendly guid.
         /// </summary>
         /// <returns>A new guid.</returns>
-        internal static string GenerateGuid()
+        public static string GenerateGuid()
         {
-            return Guid.NewGuid().ToString("B").ToUpper(CultureInfo.InvariantCulture);
+            return Guid.NewGuid().ToString("B").ToUpperInvariant();
         }
 
         /// <summary>
@@ -465,7 +462,7 @@ namespace WixToolset
             }
         }
 
-        internal static string GetFileHash(string path)
+        public static string GetFileHash(string path)
         {
             using (SHA1Managed managed = new SHA1Managed())
             {
@@ -478,6 +475,147 @@ namespace WixToolset
         }
 
         /// <summary>
+        /// Takes an id, and demodularizes it (if possible).
+        /// </summary>
+        /// <remarks>
+        /// If the output type is a module, returns a demodularized version of an id. Otherwise, returns the id.
+        /// </remarks>
+        /// <param name="outputType">The type of the output to bind.</param>
+        /// <param name="modularizationGuid">The modularization GUID.</param>
+        /// <param name="id">The id to demodularize.</param>
+        /// <returns>The demodularized id.</returns>
+        public static string Demodularize(OutputType outputType, string modularizationGuid, string id)
+        {
+            if (OutputType.Module == outputType && id.EndsWith(String.Concat(".", modularizationGuid), StringComparison.Ordinal))
+            {
+                id = id.Substring(0, id.Length - 37);
+            }
+
+            return id;
+        }
+
+        /// <summary>
+        /// Get the source/target and short/long file names from an MSI Filename column.
+        /// </summary>
+        /// <param name="value">The Filename value.</param>
+        /// <returns>An array of strings of length 4.  The contents are: short target, long target, short source, and long source.</returns>
+        /// <remarks>
+        /// If any particular file name part is not parsed, its set to null in the appropriate location of the returned array of strings.
+        /// However, the returned array will always be of length 4.
+        /// </remarks>
+        public static string[] GetNames(string value)
+        {
+            string[] names = new string[4];
+            int targetSeparator = value.IndexOf(":", StringComparison.Ordinal);
+
+            // split source and target
+            string sourceName = null;
+            string targetName = value;
+            if (0 <= targetSeparator)
+            {
+                sourceName = value.Substring(targetSeparator + 1);
+                targetName = value.Substring(0, targetSeparator);
+            }
+
+            // split the source short and long names
+            string sourceLongName = null;
+            if (null != sourceName)
+            {
+                int sourceLongNameSeparator = sourceName.IndexOf("|", StringComparison.Ordinal);
+                if (0 <= sourceLongNameSeparator)
+                {
+                    sourceLongName = sourceName.Substring(sourceLongNameSeparator + 1);
+                    sourceName = sourceName.Substring(0, sourceLongNameSeparator);
+                }
+            }
+
+            // split the target short and long names
+            int targetLongNameSeparator = targetName.IndexOf("|", StringComparison.Ordinal);
+            string targetLongName = null;
+            if (0 <= targetLongNameSeparator)
+            {
+                targetLongName = targetName.Substring(targetLongNameSeparator + 1);
+                targetName = targetName.Substring(0, targetLongNameSeparator);
+            }
+
+            // remove the long source name when its identical to the long source name
+            if (null != sourceName && sourceName == sourceLongName)
+            {
+                sourceLongName = null;
+            }
+
+            // remove the long target name when its identical to the long target name
+            if (null != targetName && targetName == targetLongName)
+            {
+                targetLongName = null;
+            }
+
+            // remove the source names when they are identical to the target names
+            if (sourceName == targetName && sourceLongName == targetLongName)
+            {
+                sourceName = null;
+                sourceLongName = null;
+            }
+
+            // target name(s)
+            if ("." != targetName)
+            {
+                names[0] = targetName;
+            }
+
+            if (null != targetLongName && "." != targetLongName)
+            {
+                names[1] = targetLongName;
+            }
+
+            // source name(s)
+            if (null != sourceName)
+            {
+                names[2] = sourceName;
+            }
+
+            if (null != sourceLongName && "." != sourceLongName)
+            {
+                names[3] = sourceLongName;
+            }
+
+            return names;
+        }
+
+        /// <summary>
+        /// Get a source/target and short/long file name from an MSI Filename column.
+        /// </summary>
+        /// <param name="value">The Filename value.</param>
+        /// <param name="source">true to get a source name; false to get a target name</param>
+        /// <param name="longName">true to get a long name; false to get a short name</param>
+        /// <returns>The name.</returns>
+        public static string GetName(string value, bool source, bool longName)
+        {
+            string[] names = GetNames(value);
+
+            if (source)
+            {
+                if (longName && null != names[3])
+                {
+                    return names[3];
+                }
+                else if (null != names[2])
+                {
+                    return names[2];
+                }
+            }
+
+            if (longName && null != names[1])
+            {
+                return names[1];
+            }
+            else
+            {
+                return names[0];
+            }
+        }
+
+        /// <summary>
         /// Get an attribute value.
         /// </summary>
         /// <param name="sourceLineNumbers">Source line information about the owner element.</param>
diff --git a/src/WixToolset.Core/Compiler.cs b/src/WixToolset.Core/Compiler.cs
index ed7cb60e..d085e788 100644
--- a/src/WixToolset.Core/Compiler.cs
+++ b/src/WixToolset.Core/Compiler.cs
@@ -11,11 +11,11 @@ namespace WixToolset
     using System.IO;
     using System.Text.RegularExpressions;
     using System.Xml.Linq;
+    using WixToolset.Core;
+    using WixToolset.Core.Native;
     using WixToolset.Data;
     using WixToolset.Data.Rows;
     using WixToolset.Extensibility;
-    using WixToolset.Msi;
-    using WixToolset.Core.Native;
     using Wix = WixToolset.Data.Serialize;
 
     /// <summary>
@@ -158,10 +158,7 @@ namespace WixToolset
         [SuppressMessage("Microsoft.Design", "CA1059:MembersShouldNotExposeCertainConcreteTypes")]
         public Intermediate Compile(XDocument source)
         {
-            if (null == source)
-            {
-                throw new ArgumentNullException("source");
-            }
+            if (null == source) throw new ArgumentNullException(nameof(source));
 
             bool encounteredError = false;
 
@@ -220,9 +217,7 @@ namespace WixToolset
                                 {
                                     if (field.Data is string)
                                     {
-                                        bool isDefault = false;
-                                        bool delayedResolve = false;
-                                        field.Data = this.componentIdPlaceholdersResolver.ResolveVariables(row.SourceLineNumbers, (string)field.Data, false, false, ref isDefault, ref delayedResolve);
+                                        field.Data = this.componentIdPlaceholdersResolver.ResolveVariables(row.SourceLineNumbers, (string)field.Data, false, false, out var defaultIgnored, out var delayedIgnored);
                                     }
                                 }
                             }
@@ -470,7 +465,8 @@ namespace WixToolset
                         case "Advertise":
                             appIdAdvertise = this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
                             break;
-                        case "Description": description = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                        case "Description":
+                            description = this.core.GetAttributeValue(sourceLineNumbers, attrib);
                             break;
                         case "DllSurrogate":
                             dllSurrogate = this.core.GetAttributeValue(sourceLineNumbers, attrib, EmptyRule.CanBeEmpty);
@@ -9471,13 +9467,13 @@ namespace WixToolset
                             targetProductName = this.core.GetAttributeValue(sourceLineNumbers, attrib);
                             break;
                         case "ApiPatchingSymbolNoImagehlpFlag":
-                            apiPatchingSymbolFlags |= (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib)) ? (int)PatchAPI.PatchInterop.PatchSymbolFlagsType.PATCH_SYMBOL_NO_IMAGEHLP : 0;
+                            apiPatchingSymbolFlags |= (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib)) ? (int)PatchSymbolFlagsType.PATCH_SYMBOL_NO_IMAGEHLP : 0;
                             break;
                         case "ApiPatchingSymbolNoFailuresFlag":
-                            apiPatchingSymbolFlags |= (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib)) ? (int)PatchAPI.PatchInterop.PatchSymbolFlagsType.PATCH_SYMBOL_NO_FAILURES : 0;
+                            apiPatchingSymbolFlags |= (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib)) ? (int)PatchSymbolFlagsType.PATCH_SYMBOL_NO_FAILURES : 0;
                             break;
                         case "ApiPatchingSymbolUndecoratedTooFlag":
-                            apiPatchingSymbolFlags |= (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib)) ? (int)PatchAPI.PatchInterop.PatchSymbolFlagsType.PATCH_SYMBOL_UNDECORATED_TOO : 0;
+                            apiPatchingSymbolFlags |= (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib)) ? (int)PatchSymbolFlagsType.PATCH_SYMBOL_UNDECORATED_TOO : 0;
                             break;
                         case "OptimizePatchSizeForLargeFiles":
                             optimizePatchSizeForLargeFiles = (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib));
@@ -11802,7 +11798,7 @@ namespace WixToolset
         private void ParseProductElement(XElement node)
         {
             SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
-            int codepage = 0;
+            int codepage = 65001;
             string productCode = null;
             string upgradeCode = null;
             string manufacturer = null;
diff --git a/src/WixToolset.Core/CompilerCore.cs b/src/WixToolset.Core/CompilerCore.cs
index 8640a2da..8f4703f7 100644
--- a/src/WixToolset.Core/CompilerCore.cs
+++ b/src/WixToolset.Core/CompilerCore.cs
@@ -45,10 +45,6 @@ namespace WixToolset
         internal static readonly XNamespace W3SchemaPrefix = "http://www.w3.org/";
         internal static readonly XNamespace WixNamespace = "http://wixtoolset.org/schemas/v4/wxs";
 
-        public const int DefaultMaximumUncompressedMediaSize = 200; // Default value is 200 MB
-        public const int MinValueOfMaxCabSizeForLargeFileSplitting = 20; // 20 MB
-        public const int MaxValueOfMaxCabSizeForLargeFileSplitting = 2 * 1024; // 2048 MB (i.e. 2 GB)
-
         private static readonly Regex AmbiguousFilename = new Regex(@"^.{6}\~\d", RegexOptions.Compiled);
 
         private const string IllegalLongFilenameCharacters = @"[\\\?|><:/\*""]"; // illegal: \ ? | > < : / * "
@@ -67,6 +63,11 @@ namespace WixToolset
 
         private static readonly Regex LegalIdentifierWithAccess = new Regex(@"^((?<access>public|internal|protected|private)\s+)?(?<id>[_A-Za-z][0-9A-Za-z_\.]*)$", RegexOptions.Compiled | RegexOptions.ExplicitCapture);
 
+        public const int DefaultMaximumUncompressedMediaSize = 200; // Default value is 200 MB
+        public const int MinValueOfMaxCabSizeForLargeFileSplitting = 20; // 20 MB
+        public const int MaxValueOfMaxCabSizeForLargeFileSplitting = 2 * 1024; // 2048 MB (i.e. 2 GB)
+
+
         // Built-in variables (from burn\engine\variable.cpp, "vrgBuiltInVariables", around line 113)
         private static readonly List<String> BuiltinBundleVariables = new List<string>(
             new string[] {
diff --git a/src/WixToolset.Core/Data/messages.xml b/src/WixToolset.Core/Data/messages.xml
index edc98147..d981e2d1 100644
--- a/src/WixToolset.Core/Data/messages.xml
+++ b/src/WixToolset.Core/Data/messages.xml
@@ -957,12 +957,6 @@
                 <Parameter Type="System.String" Name="exceptionMessage" />
             </Instance>
         </Message>
-        <Message Id="InvalidFileName" Number="85">
-            <Instance>
-                Invalid file name '{0}'.
-                <Parameter Type="System.String" Name="fileName" />
-            </Instance>
-        </Message>
         <Message Id="ReferenceLoopDetected" Number="86">
             <Instance>
                 A circular reference of groups was detected. The infinite loop includes: {0}. Group references must form a directed acyclic graph.
@@ -2138,12 +2132,6 @@
                 This patch is not uninstallable. The 'Patch' element's attribute 'AllowRemoval' should be set to 'no'.
             </Instance>
         </Message>
-        <Message Id="PathTooLong" Number="262">
-            <Instance>
-                '{0}' is too long, the fully qualified file name must be less than 260 characters, and the directory name must be less than 248 characters.
-                <Parameter Type="System.String" Name="fileName" />
-            </Instance>
-        </Message>
         <Message Id="FileTooLarge" Number="263">
             <Instance>
                 '{0}' is too large, file size must be less than 2147483648.
diff --git a/src/WixToolset.Core/Decompiler.cs b/src/WixToolset.Core/Decompiler.cs
index 249b5788..e72b0104 100644
--- a/src/WixToolset.Core/Decompiler.cs
+++ b/src/WixToolset.Core/Decompiler.cs
@@ -3,7 +3,6 @@
 namespace WixToolset
 {
     using System;
-    using System.CodeDom.Compiler;
     using System.Collections;
     using System.Collections.Generic;
     using System.Collections.Specialized;
@@ -15,9 +14,9 @@ namespace WixToolset
     using WixToolset.Data;
     using WixToolset.Data.Rows;
     using WixToolset.Extensibility;
-    using WixToolset.Msi;
     using WixToolset.Core.Native;
     using Wix = WixToolset.Data.Serialize;
+    using WixToolset.Core;
 
     /// <summary>
     /// Decompiles an msi database into WiX source.
@@ -5201,7 +5200,7 @@ namespace WixToolset
 
                 directory.Id = Convert.ToString(row[0]);
 
-                string[] names = Installer.GetNames(Convert.ToString(row[2]));
+                string[] names = Common.GetNames(Convert.ToString(row[2]));
 
                 if (String.Equals(directory.Id, "TARGETDIR", StringComparison.Ordinal) && !String.Equals(names[0], "SourceDir", StringComparison.Ordinal))
                 {
@@ -5319,7 +5318,7 @@ namespace WixToolset
 
                 if (null != row[3])
                 {
-                    string[] names = Installer.GetNames(Convert.ToString(row[3]));
+                    string[] names = Common.GetNames(Convert.ToString(row[3]));
                     if (null != names[0] && null != names[1])
                     {
                         copyFile.DestinationShortName = names[0];
@@ -5788,7 +5787,7 @@ namespace WixToolset
 
                 file.Id = fileRow.File;
 
-                string[] names = Installer.GetNames(fileRow.FileName);
+                string[] names = Common.GetNames(fileRow.FileName);
                 if (null != names[0] && null != names[1])
                 {
                     file.ShortName = names[0];
@@ -5974,7 +5973,7 @@ namespace WixToolset
 
                 iniFile.Id = Convert.ToString(row[0]);
 
-                string[] names = Installer.GetNames(Convert.ToString(row[1]));
+                string[] names = Common.GetNames(Convert.ToString(row[1]));
 
                 if (null != names[0])
                 {
@@ -6044,7 +6043,7 @@ namespace WixToolset
 
                 iniFileSearch.Id = Convert.ToString(row[0]);
 
-                string[] names = Installer.GetNames(Convert.ToString(row[1]));
+                string[] names = Common.GetNames(Convert.ToString(row[1]));
                 if (null != names[0] && null != names[1])
                 {
                     iniFileSearch.ShortName = names[0];
@@ -6681,7 +6680,7 @@ namespace WixToolset
 
                 if (null != row[3])
                 {
-                    string[] names = Installer.GetNames(Convert.ToString(row[3]));
+                    string[] names = Common.GetNames(Convert.ToString(row[3]));
                     if (null != names[0] && null != names[1])
                     {
                         copyFile.DestinationShortName = names[0];
@@ -8007,7 +8006,7 @@ namespace WixToolset
 
                     removeFile.Id = Convert.ToString(row[0]);
 
-                    string[] names = Installer.GetNames(Convert.ToString(row[2]));
+                    string[] names = Common.GetNames(Convert.ToString(row[2]));
                     if (null != names[0] && null != names[1])
                     {
                         removeFile.ShortName = names[0];
@@ -8062,7 +8061,7 @@ namespace WixToolset
 
                 iniFile.Id = Convert.ToString(row[0]);
 
-                string[] names = Installer.GetNames(Convert.ToString(row[1]));
+                string[] names = Common.GetNames(Convert.ToString(row[1]));
                 if (null != names[0] && null != names[1])
                 {
                     iniFile.ShortName = names[0];
@@ -8531,7 +8530,7 @@ namespace WixToolset
 
                 shortcut.Directory = Convert.ToString(row[1]);
 
-                string[] names = Installer.GetNames(Convert.ToString(row[2]));
+                string[] names = Common.GetNames(Convert.ToString(row[2]));
                 if (null != names[0] && null != names[1])
                 {
                     shortcut.ShortName = names[0];
@@ -8654,7 +8653,7 @@ namespace WixToolset
 
                 fileSearch.Id = Convert.ToString(row[0]);
 
-                string[] names = Installer.GetNames(Convert.ToString(row[1]));
+                string[] names = Common.GetNames(Convert.ToString(row[1]));
                 if (null != names[0])
                 {
                     // it is permissable to just have a long name
diff --git a/src/WixToolset.Core/Extensibility/HeatExtension.cs b/src/WixToolset.Core/Extensibility/HeatExtension.cs
index 5e292220..48e1a93b 100644
--- a/src/WixToolset.Core/Extensibility/HeatExtension.cs
+++ b/src/WixToolset.Core/Extensibility/HeatExtension.cs
@@ -3,14 +3,10 @@
 namespace WixToolset.Extensibility
 {
     using System;
-    using System.Collections.Generic;
     using System.IO;
     using System.Reflection;
-    using WixToolset;
     using WixToolset.Data;
-    using WixToolset.Extensibilty;
     using WixToolset.Tools;
-    using Wix = WixToolset.Data.Serialize;
 
     /// <summary>
     /// A command line option.
diff --git a/src/WixToolset.Core/Extensibility/IHeatCore.cs b/src/WixToolset.Core/Extensibility/IHeatCore.cs
index bc853b24..dbfc8929 100644
--- a/src/WixToolset.Core/Extensibility/IHeatCore.cs
+++ b/src/WixToolset.Core/Extensibility/IHeatCore.cs
@@ -1,6 +1,6 @@
 // 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.Extensibilty
+namespace WixToolset.Extensibility
 {
     using WixToolset.Data;
 
diff --git a/src/WixToolset.Core/ExtensionManager.cs b/src/WixToolset.Core/ExtensionManager.cs
index 45cb65ec..7e40571b 100644
--- a/src/WixToolset.Core/ExtensionManager.cs
+++ b/src/WixToolset.Core/ExtensionManager.cs
@@ -8,8 +8,9 @@ namespace WixToolset
     using System.Linq;
     using System.Reflection;
     using WixToolset.Data;
+    using WixToolset.Extensibility;
 
-    public class ExtensionManager
+    public class ExtensionManager : IExtensionManager
     {
         private List<Assembly> extensionAssemblies = new List<Assembly>();
 
@@ -67,8 +68,7 @@ namespace WixToolset
         /// <returns>Extensions created of the specified type.</returns>
         public IEnumerable<T> Create<T>() where T : class
         {
-            var extensionType = typeof(T);
-            var types = this.extensionAssemblies.SelectMany(a => a.GetTypes().Where(t => !t.IsAbstract && !t.IsInterface && extensionType.IsAssignableFrom(t)));
+            var types = this.extensionAssemblies.SelectMany(a => a.GetTypes().Where(t => !t.IsAbstract && !t.IsInterface && typeof(T).IsAssignableFrom(t)));
             return types.Select(t => (T)Activator.CreateInstance(t)).ToList();
         }
 
diff --git a/src/WixToolset.Core/HeatCore.cs b/src/WixToolset.Core/HeatCore.cs
index 5c5defe8..01233c40 100644
--- a/src/WixToolset.Core/HeatCore.cs
+++ b/src/WixToolset.Core/HeatCore.cs
@@ -2,11 +2,8 @@
 
 namespace WixToolset.Tools
 {
-    using System;
-    using System.Reflection;
     using WixToolset.Data;
-    using WixToolset.Extensibilty;
-    using Wix = WixToolset.Data.Serialize;
+    using WixToolset.Extensibility;
 
     /// <summary>
     /// The WiX Toolset Harvester application core.
diff --git a/src/WixToolset.Core/IncribeContext.cs b/src/WixToolset.Core/IncribeContext.cs
new file mode 100644
index 00000000..604ba5d1
--- /dev/null
+++ b/src/WixToolset.Core/IncribeContext.cs
@@ -0,0 +1,20 @@
+// 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
+{
+    using WixToolset.Data;
+    using WixToolset.Extensibility;
+
+    internal class InscribeContext : IInscribeContext
+    {
+        public Messaging Messaging { get; } = Messaging.Instance;
+
+        public string IntermediateFolder { get; set; }
+
+        public string InputFilePath { get; set; }
+
+        public string SignedEngineFile { get; set; }
+
+        public string OutputFile { get; set; }
+    }
+}
diff --git a/src/WixToolset.Core/Inscriber.cs b/src/WixToolset.Core/Inscriber.cs
index 5b467ec1..f01e0629 100644
--- a/src/WixToolset.Core/Inscriber.cs
+++ b/src/WixToolset.Core/Inscriber.cs
@@ -2,17 +2,8 @@
 
 namespace WixToolset
 {
-    using System;
-    using System.CodeDom.Compiler;
-    using System.Collections.Generic;
-    using System.Globalization;
     using System.IO;
-    using System.Runtime.InteropServices;
-    using System.Security.Cryptography.X509Certificates;
-    using WixToolset.Bind.Bundles;
     using WixToolset.Data;
-    using WixToolset.Msi;
-    using WixToolset.Core.Native;
 
     /// <summary>
     /// Converts a wixout representation of an MSM database into a ComponentGroup the form of WiX source.
@@ -81,41 +72,41 @@ namespace WixToolset
         /// <returns>True if bundle was updated.</returns>
         public bool InscribeBundleEngine(string bundleFile, string outputFile)
         {
-            string tempFile = Path.Combine(this.TempFilesLocation, "bundle_engine_unsigned.exe");
-
-            using (BurnReader reader = BurnReader.Open(bundleFile))
-            using (FileStream writer = File.Open(tempFile, FileMode.Create, FileAccess.Write, FileShare.Read | FileShare.Delete))
-            {
-                reader.Stream.Seek(0, SeekOrigin.Begin);
-
-                byte[] buffer = new byte[4 * 1024];
-                int total = 0;
-                int read = 0;
-                do
-                {
-                    read = Math.Min(buffer.Length, (int)reader.EngineSize - total);
-
-                    read = reader.Stream.Read(buffer, 0, read);
-                    writer.Write(buffer, 0, read);
-
-                    total += read;
-                } while (total < reader.EngineSize && 0 < read);
-
-                if (total != reader.EngineSize)
-                {
-                    throw new InvalidOperationException("Failed to copy engine out of bundle.");
-                }
-
-                // TODO: update writer with detached container signatures.
-            }
-
-            Directory.CreateDirectory(Path.GetDirectoryName(outputFile));
-            if (File.Exists(outputFile))
-            {
-                File.Delete(outputFile);
-            }
-            File.Move(tempFile, outputFile);
-            WixToolset.Core.Native.NativeMethods.ResetAcls(new string[] { outputFile }, 1);
+            //string tempFile = Path.Combine(this.TempFilesLocation, "bundle_engine_unsigned.exe");
+
+            //using (BurnReader reader = BurnReader.Open(bundleFile))
+            //using (FileStream writer = File.Open(tempFile, FileMode.Create, FileAccess.Write, FileShare.Read | FileShare.Delete))
+            //{
+            //    reader.Stream.Seek(0, SeekOrigin.Begin);
+
+            //    byte[] buffer = new byte[4 * 1024];
+            //    int total = 0;
+            //    int read = 0;
+            //    do
+            //    {
+            //        read = Math.Min(buffer.Length, (int)reader.EngineSize - total);
+
+            //        read = reader.Stream.Read(buffer, 0, read);
+            //        writer.Write(buffer, 0, read);
+
+            //        total += read;
+            //    } while (total < reader.EngineSize && 0 < read);
+
+            //    if (total != reader.EngineSize)
+            //    {
+            //        throw new InvalidOperationException("Failed to copy engine out of bundle.");
+            //    }
+
+            //    // TODO: update writer with detached container signatures.
+            //}
+
+            //Directory.CreateDirectory(Path.GetDirectoryName(outputFile));
+            //if (File.Exists(outputFile))
+            //{
+            //    File.Delete(outputFile);
+            //}
+            //File.Move(tempFile, outputFile);
+            //WixToolset.Core.Native.NativeMethods.ResetAcls(new string[] { outputFile }, 1);
 
             return true;
         }
@@ -129,36 +120,37 @@ namespace WixToolset
         /// <returns>True if bundle was updated.</returns>
         public bool InscribeBundle(string bundleFile, string signedEngineFile, string outputFile)
         {
-            bool inscribed = false;
-            string tempFile = Path.Combine(this.TempFilesLocation, "bundle_engine_signed.exe");
-
-            using (BurnReader reader = BurnReader.Open(bundleFile))
-            {
-                File.Copy(signedEngineFile, tempFile, true);
-
-                // If there was an attached container on the original (unsigned) bundle, put it back.
-                if (reader.AttachedContainerSize > 0)
-                {
-                    reader.Stream.Seek(reader.AttachedContainerAddress, SeekOrigin.Begin);
-
-                    using (BurnWriter writer = BurnWriter.Open(tempFile))
-                    {
-                        writer.RememberThenResetSignature();
-                        writer.AppendContainer(reader.Stream, reader.AttachedContainerSize, BurnCommon.Container.Attached);
-                        inscribed = true;
-                    }
-                }
-            }
-
-            Directory.CreateDirectory(Path.GetDirectoryName(outputFile));
-            if (File.Exists(outputFile))
-            {
-                File.Delete(outputFile);
-            }
-            File.Move(tempFile, outputFile);
-            WixToolset.Core.Native.NativeMethods.ResetAcls(new string[] { outputFile }, 1);
-
-            return inscribed;
+            //bool inscribed = false;
+            //string tempFile = Path.Combine(this.TempFilesLocation, "bundle_engine_signed.exe");
+
+            //using (BurnReader reader = BurnReader.Open(bundleFile))
+            //{
+            //    File.Copy(signedEngineFile, tempFile, true);
+
+            //    // If there was an attached container on the original (unsigned) bundle, put it back.
+            //    if (reader.AttachedContainerSize > 0)
+            //    {
+            //        reader.Stream.Seek(reader.AttachedContainerAddress, SeekOrigin.Begin);
+
+            //        using (BurnWriter writer = BurnWriter.Open(tempFile))
+            //        {
+            //            writer.RememberThenResetSignature();
+            //            writer.AppendContainer(reader.Stream, reader.AttachedContainerSize, BurnCommon.Container.Attached);
+            //            inscribed = true;
+            //        }
+            //    }
+            //}
+
+            //Directory.CreateDirectory(Path.GetDirectoryName(outputFile));
+            //if (File.Exists(outputFile))
+            //{
+            //    File.Delete(outputFile);
+            //}
+            //File.Move(tempFile, outputFile);
+            //WixToolset.Core.Native.NativeMethods.ResetAcls(new string[] { outputFile }, 1);
+
+            //return inscribed;
+            return false;
         }
 
         /// <summary>
@@ -170,256 +162,257 @@ namespace WixToolset
         /// <returns>True if database is updated.</returns>
         public bool InscribeDatabase(string databaseFile, string outputFile, bool tidy)
         {
-            // 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;
-
-            FileAttributes attributes = File.GetAttributes(databaseFile);
-            if (FileAttributes.ReadOnly == (attributes & FileAttributes.ReadOnly))
-            {
-                this.OnMessage(WixErrors.ReadOnlyOutputFile(databaseFile));
-                return shouldCommit;
-            }
-
-            using (Database database = new Database(databaseFile, 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;
-
-                // list of certificates for this database (hash/identifier)
-                Dictionary<string, string> certificates = new Dictionary<string, string>();
-
-                // Reset the in-memory tables for this new database
-                Table digitalSignatureTable = new Table(null, this.tableDefinitions["MsiDigitalSignature"]);
-                Table digitalCertificateTable = new Table(null, 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'"))
-                    {
-                        while (true)
-                        {
-                            using (Record digitalSignatureRecord = digitalSignatureView.Fetch())
-                            {
-                                if (null == digitalSignatureRecord)
-                                {
-                                    break;
-                                }
-
-                                Row digitalSignatureRow = null;
-                                digitalSignatureRow = digitalSignatureTable.CreateRow(null);
-
-                                string table = digitalSignatureRecord.GetString(0);
-                                string signObject = digitalSignatureRecord.GetString(1);
-
-                                digitalSignatureRow[0] = table;
-                                digitalSignatureRow[1] = signObject;
-                                digitalSignatureRow[2] = digitalSignatureRecord.GetString(2);
-
-                                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.TempFilesLocation, "MsiDigitalSignature");
-                                    string hashFileName = string.Concat(table, ".", signObject, ".bin");
-
-                                    Directory.CreateDirectory(hashPath);
-                                    hashPath = Path.Combine(hashPath, hashFileName);
-
-                                    using (FileStream fs = File.Create(hashPath))
-                                    {
-                                        int bytesRead;
-                                        byte[] buffer = new byte[1024 * 4];
-
-                                        while (0 != (bytesRead = digitalSignatureRecord.GetStream(3, buffer, buffer.Length)))
-                                        {
-                                            fs.Write(buffer, 0, bytesRead);
-                                        }
-                                    }
-
-                                    digitalSignatureRow[3] = hashFileName;
-                                }
-                            }
-                        }
-                    }
-                }
-
-                // If any digital certificates exist, extract and preserve them
-                if (database.TableExists("MsiDigitalCertificate"))
-                {
-                    using (View digitalCertificateView = database.OpenExecuteView("SELECT * FROM `MsiDigitalCertificate`"))
-                    {
-                        while (true)
-                        {
-                            using (Record digitalCertificateRecord = digitalCertificateView.Fetch())
-                            {
-                                if (null == digitalCertificateRecord)
-                                {
-                                    break;
-                                }
-
-                                string 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.TempFilesLocation, "MsiDigitalCertificate");
-                                Directory.CreateDirectory(certPath);
-                                certPath = Path.Combine(certPath, string.Concat(certificateId, ".cer"));
-
-                                using (FileStream fs = File.Create(certPath))
-                                {
-                                    int bytesRead;
-                                    byte[] buffer = new byte[1024 * 4];
-
-                                    while (0 != (bytesRead = digitalCertificateRecord.GetStream(2, buffer, buffer.Length)))
-                                    {
-                                        fs.Write(buffer, 0, bytesRead);
-                                    }
-                                }
-
-                                // Add it to our "add to MsiDigitalCertificate" table dictionary
-                                Row 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");
-
-                                // Load the cert to get it's thumbprint
-                                X509Certificate cert = X509Certificate.CreateFromCertFile(certPath);
-                                X509Certificate2 cert2 = new X509Certificate2(cert);
-
-                                certificates.Add(cert2.Thumbprint, certificateId);
-                            }
-                        }
-                    }
-                }
-
-                using (View mediaView = database.OpenExecuteView("SELECT * FROM `Media`"))
-                {
-                    while (true)
-                    {
-                        using (Record mediaRecord = mediaView.Fetch())
-                        {
-                            if (null == mediaRecord)
-                            {
-                                break;
-                            }
-
-                            X509Certificate2 cert2 = null;
-                            Row digitalSignatureRow = null;
-
-                            string 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(databaseFile), cabName);
-
-                            // If the cabs aren't there, throw an error but continue to catch the other errors
-                            if (!File.Exists(cabPath))
-                            {
-                                this.OnMessage(WixErrors.WixFileNotFound(cabPath));
-                                continue;
-                            }
-
-                            try
-                            {
-                                // Get the certificate from the cab
-                                X509Certificate signedFileCert = X509Certificate.CreateFromSignedFile(cabPath);
-                                cert2 = new X509Certificate2(signedFileCert);
-                            }
-                            catch (System.Security.Cryptography.CryptographicException e)
-                            {
-                                uint 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
-                                {
-                                    foundUnsignedExternals = true;
-                                    continue;
-                                }
-
-                                // todo: exactly which HRESULT corresponds to this issue?
-                                // If it's one of these exact platforms, warn the user that it may be due to their OS.
-                                if ((5 == Environment.OSVersion.Version.Major && 2 == Environment.OSVersion.Version.Minor) || // W2K3
-                                        (5 == Environment.OSVersion.Version.Major && 1 == Environment.OSVersion.Version.Minor)) // XP
-                                {
-                                    this.OnMessage(WixErrors.UnableToGetAuthenticodeCertOfFileDownlevelOS(cabPath, String.Format(CultureInfo.InvariantCulture, "HRESULT: 0x{0:x8}", HResult)));
-                                }
-                                else // otherwise, generic error
-                                {
-                                    this.OnMessage(WixErrors.UnableToGetAuthenticodeCertOfFile(cabPath, String.Format(CultureInfo.InvariantCulture, "HRESULT: 0x{0:x8}", HResult)));
-                                }
-                            }
-
-                            // If we haven't added this cert to the MsiDigitalCertificate table, set it up to be added
-                            if (!certificates.ContainsKey(cert2.Thumbprint))
-                            {
-                                // generate a stable identifier
-                                string certificateGeneratedId = Common.GenerateIdentifier("cer", cert2.Thumbprint);
-
-                                // Add it to our "add to MsiDigitalCertificate" table dictionary
-                                Row 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.TempFilesLocation, "MsiDigitalCertificate");
-                                Directory.CreateDirectory(certPath);
-                                certPath = Path.Combine(certPath, string.Concat(cert2.Thumbprint, ".cer"));
-                                File.Delete(certPath);
-
-                                using (BinaryWriter 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");
-
-                                certificates.Add(cert2.Thumbprint, certificateGeneratedId);
-                            }
-
-                            digitalSignatureRow = digitalSignatureTable.CreateRow(null);
-
-                            digitalSignatureRow[0] = "Media";
-                            digitalSignatureRow[1] = cabId;
-                            digitalSignatureRow[2] = certificates[cert2.Thumbprint];
-                        }
-                    }
-                }
-
-                if (digitalCertificateTable.Rows.Count > 0)
-                {
-                    database.ImportTable(codepage, digitalCertificateTable, this.TempFilesLocation, true);
-                    shouldCommit = true;
-                }
-
-                if (digitalSignatureTable.Rows.Count > 0)
-                {
-                    database.ImportTable(codepage, digitalSignatureTable, this.TempFilesLocation, true);
-                    shouldCommit = true;
-                }
-
-                // TODO: if we created the table(s), then we should add the _Validation records for them.
-
-                certificates = null;
-
-                // If we did find external cabs but none of them were signed, give a warning
-                if (foundUnsignedExternals)
-                {
-                    this.OnMessage(WixWarnings.ExternalCabsAreNotSigned(databaseFile));
-                }
-
-                if (shouldCommit)
-                {
-                    database.Commit();
-                }
-            }
-
-            return shouldCommit;
+            //// 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;
+
+            //FileAttributes attributes = File.GetAttributes(databaseFile);
+            //if (FileAttributes.ReadOnly == (attributes & FileAttributes.ReadOnly))
+            //{
+            //    this.OnMessage(WixErrors.ReadOnlyOutputFile(databaseFile));
+            //    return shouldCommit;
+            //}
+
+            //using (Database database = new Database(databaseFile, 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;
+
+            //    // list of certificates for this database (hash/identifier)
+            //    Dictionary<string, string> certificates = new Dictionary<string, string>();
+
+            //    // Reset the in-memory tables for this new database
+            //    Table digitalSignatureTable = new Table(null, this.tableDefinitions["MsiDigitalSignature"]);
+            //    Table digitalCertificateTable = new Table(null, 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'"))
+            //        {
+            //            while (true)
+            //            {
+            //                using (Record digitalSignatureRecord = digitalSignatureView.Fetch())
+            //                {
+            //                    if (null == digitalSignatureRecord)
+            //                    {
+            //                        break;
+            //                    }
+
+            //                    Row digitalSignatureRow = null;
+            //                    digitalSignatureRow = digitalSignatureTable.CreateRow(null);
+
+            //                    string table = digitalSignatureRecord.GetString(0);
+            //                    string signObject = digitalSignatureRecord.GetString(1);
+
+            //                    digitalSignatureRow[0] = table;
+            //                    digitalSignatureRow[1] = signObject;
+            //                    digitalSignatureRow[2] = digitalSignatureRecord.GetString(2);
+
+            //                    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.TempFilesLocation, "MsiDigitalSignature");
+            //                        string hashFileName = string.Concat(table, ".", signObject, ".bin");
+
+            //                        Directory.CreateDirectory(hashPath);
+            //                        hashPath = Path.Combine(hashPath, hashFileName);
+
+            //                        using (FileStream fs = File.Create(hashPath))
+            //                        {
+            //                            int bytesRead;
+            //                            byte[] buffer = new byte[1024 * 4];
+
+            //                            while (0 != (bytesRead = digitalSignatureRecord.GetStream(3, buffer, buffer.Length)))
+            //                            {
+            //                                fs.Write(buffer, 0, bytesRead);
+            //                            }
+            //                        }
+
+            //                        digitalSignatureRow[3] = hashFileName;
+            //                    }
+            //                }
+            //            }
+            //        }
+            //    }
+
+            //    // If any digital certificates exist, extract and preserve them
+            //    if (database.TableExists("MsiDigitalCertificate"))
+            //    {
+            //        using (View digitalCertificateView = database.OpenExecuteView("SELECT * FROM `MsiDigitalCertificate`"))
+            //        {
+            //            while (true)
+            //            {
+            //                using (Record digitalCertificateRecord = digitalCertificateView.Fetch())
+            //                {
+            //                    if (null == digitalCertificateRecord)
+            //                    {
+            //                        break;
+            //                    }
+
+            //                    string 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.TempFilesLocation, "MsiDigitalCertificate");
+            //                    Directory.CreateDirectory(certPath);
+            //                    certPath = Path.Combine(certPath, string.Concat(certificateId, ".cer"));
+
+            //                    using (FileStream fs = File.Create(certPath))
+            //                    {
+            //                        int bytesRead;
+            //                        byte[] buffer = new byte[1024 * 4];
+
+            //                        while (0 != (bytesRead = digitalCertificateRecord.GetStream(2, buffer, buffer.Length)))
+            //                        {
+            //                            fs.Write(buffer, 0, bytesRead);
+            //                        }
+            //                    }
+
+            //                    // Add it to our "add to MsiDigitalCertificate" table dictionary
+            //                    Row 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");
+
+            //                    // Load the cert to get it's thumbprint
+            //                    X509Certificate cert = X509Certificate.CreateFromCertFile(certPath);
+            //                    X509Certificate2 cert2 = new X509Certificate2(cert);
+
+            //                    certificates.Add(cert2.Thumbprint, certificateId);
+            //                }
+            //            }
+            //        }
+            //    }
+
+            //    using (View mediaView = database.OpenExecuteView("SELECT * FROM `Media`"))
+            //    {
+            //        while (true)
+            //        {
+            //            using (Record mediaRecord = mediaView.Fetch())
+            //            {
+            //                if (null == mediaRecord)
+            //                {
+            //                    break;
+            //                }
+
+            //                X509Certificate2 cert2 = null;
+            //                Row digitalSignatureRow = null;
+
+            //                string 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(databaseFile), cabName);
+
+            //                // If the cabs aren't there, throw an error but continue to catch the other errors
+            //                if (!File.Exists(cabPath))
+            //                {
+            //                    this.OnMessage(WixErrors.WixFileNotFound(cabPath));
+            //                    continue;
+            //                }
+
+            //                try
+            //                {
+            //                    // Get the certificate from the cab
+            //                    X509Certificate signedFileCert = X509Certificate.CreateFromSignedFile(cabPath);
+            //                    cert2 = new X509Certificate2(signedFileCert);
+            //                }
+            //                catch (System.Security.Cryptography.CryptographicException e)
+            //                {
+            //                    uint 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
+            //                    {
+            //                        foundUnsignedExternals = true;
+            //                        continue;
+            //                    }
+
+            //                    // todo: exactly which HRESULT corresponds to this issue?
+            //                    // If it's one of these exact platforms, warn the user that it may be due to their OS.
+            //                    if ((5 == Environment.OSVersion.Version.Major && 2 == Environment.OSVersion.Version.Minor) || // W2K3
+            //                            (5 == Environment.OSVersion.Version.Major && 1 == Environment.OSVersion.Version.Minor)) // XP
+            //                    {
+            //                        this.OnMessage(WixErrors.UnableToGetAuthenticodeCertOfFileDownlevelOS(cabPath, String.Format(CultureInfo.InvariantCulture, "HRESULT: 0x{0:x8}", HResult)));
+            //                    }
+            //                    else // otherwise, generic error
+            //                    {
+            //                        this.OnMessage(WixErrors.UnableToGetAuthenticodeCertOfFile(cabPath, String.Format(CultureInfo.InvariantCulture, "HRESULT: 0x{0:x8}", HResult)));
+            //                    }
+            //                }
+
+            //                // If we haven't added this cert to the MsiDigitalCertificate table, set it up to be added
+            //                if (!certificates.ContainsKey(cert2.Thumbprint))
+            //                {
+            //                    // generate a stable identifier
+            //                    string certificateGeneratedId = Common.GenerateIdentifier("cer", cert2.Thumbprint);
+
+            //                    // Add it to our "add to MsiDigitalCertificate" table dictionary
+            //                    Row 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.TempFilesLocation, "MsiDigitalCertificate");
+            //                    Directory.CreateDirectory(certPath);
+            //                    certPath = Path.Combine(certPath, string.Concat(cert2.Thumbprint, ".cer"));
+            //                    File.Delete(certPath);
+
+            //                    using (BinaryWriter 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");
+
+            //                    certificates.Add(cert2.Thumbprint, certificateGeneratedId);
+            //                }
+
+            //                digitalSignatureRow = digitalSignatureTable.CreateRow(null);
+
+            //                digitalSignatureRow[0] = "Media";
+            //                digitalSignatureRow[1] = cabId;
+            //                digitalSignatureRow[2] = certificates[cert2.Thumbprint];
+            //            }
+            //        }
+            //    }
+
+            //    if (digitalCertificateTable.Rows.Count > 0)
+            //    {
+            //        database.ImportTable(codepage, digitalCertificateTable, this.TempFilesLocation, true);
+            //        shouldCommit = true;
+            //    }
+
+            //    if (digitalSignatureTable.Rows.Count > 0)
+            //    {
+            //        database.ImportTable(codepage, digitalSignatureTable, this.TempFilesLocation, true);
+            //        shouldCommit = true;
+            //    }
+
+            //    // TODO: if we created the table(s), then we should add the _Validation records for them.
+
+            //    certificates = null;
+
+            //    // If we did find external cabs but none of them were signed, give a warning
+            //    if (foundUnsignedExternals)
+            //    {
+            //        this.OnMessage(WixWarnings.ExternalCabsAreNotSigned(databaseFile));
+            //    }
+
+            //    if (shouldCommit)
+            //    {
+            //        database.Commit();
+            //    }
+            //}
+
+            //return shouldCommit;
+            return false;
         }
 
         /// <summary>
diff --git a/src/WixToolset.Core/Librarian.cs b/src/WixToolset.Core/Librarian.cs
index 66a8c32d..092d81dc 100644
--- a/src/WixToolset.Core/Librarian.cs
+++ b/src/WixToolset.Core/Librarian.cs
@@ -1,10 +1,11 @@
 // 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
+namespace WixToolset.Core
 {
     using System;
     using System.Collections.Generic;
     using System.Linq;
+    using WixToolset.Core.Bind;
     using WixToolset.Data;
     using WixToolset.Link;
 
@@ -13,20 +14,41 @@ namespace WixToolset
     /// </summary>
     public sealed class Librarian
     {
+        public Librarian(LibraryContext context)
+        {
+            this.Context = context;
+        }
+
+        private LibraryContext Context { get; }
+
         /// <summary>
         /// Create a library by combining several intermediates (objects).
         /// </summary>
         /// <param name="sections">The sections to combine into a library.</param>
         /// <returns>Returns the new library.</returns>
-        public Library Combine(IEnumerable<Section> sections, IEnumerable<Localization> localizations, ILibraryBinaryFileResolver resolver)
+        public Library Combine()
         {
-            var localizationsByCulture = CollateLocalizations(localizations);
+            foreach (var extension in this.Context.Extensions)
+            {
+                extension.PreCombine(this.Context);
+            }
+
+            var fileResolver = new FileResolver(this.Context.BindPaths, this.Context.Extensions);
 
-            var embedFilePaths = ResolveFilePathsToEmbed(sections, resolver);
+            var localizationsByCulture = CollateLocalizations(this.Context.Localizations);
 
-            var library = new Library(sections, localizationsByCulture, embedFilePaths);
+            var embedFilePaths = ResolveFilePathsToEmbed(this.Context.Sections, fileResolver);
 
-            return this.Validate(library);
+            var library = new Library(this.Context.Sections, localizationsByCulture, embedFilePaths);
+
+            this.Validate(library);
+
+            foreach (var extension in this.Context.Extensions)
+            {
+                extension.PostCombine(library);
+            }
+
+            return library;
         }
 
         /// <summary>
@@ -70,12 +92,12 @@ namespace WixToolset
             return localizationsByCulture;
         }
 
-        private static List<string> ResolveFilePathsToEmbed(IEnumerable<Section> sections, ILibraryBinaryFileResolver resolver)
+        private List<string> ResolveFilePathsToEmbed(IEnumerable<Section> sections, FileResolver fileResolver)
         {
             var embedFilePaths = new List<string>();
 
             // Resolve paths to files that are to be embedded in the library.
-            if (null != resolver)
+            if (this.Context.BindFiles)
             {
                 foreach (Table table in sections.SelectMany(s => s.Tables))
                 {
@@ -85,7 +107,10 @@ namespace WixToolset
                         {
                             if (null != objectField.Data)
                             {
-                                string file = resolver.Resolve(row.SourceLineNumbers, table.Name, (string)objectField.Data);
+                                string resolvedPath = this.Context.WixVariableResolver.ResolveVariables(row.SourceLineNumbers, (string)objectField.Data, false);
+
+                                string file = fileResolver.Resolve(row.SourceLineNumbers, table.Name, resolvedPath);
+
                                 if (!String.IsNullOrEmpty(file))
                                 {
                                     // File was successfully resolved so track the embedded index as the embedded file index.
diff --git a/src/WixToolset.Core/LibraryContext.cs b/src/WixToolset.Core/LibraryContext.cs
new file mode 100644
index 00000000..36e38739
--- /dev/null
+++ b/src/WixToolset.Core/LibraryContext.cs
@@ -0,0 +1,23 @@
+// 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
+{
+    using System.Collections.Generic;
+    using WixToolset.Data;
+    using WixToolset.Extensibility;
+
+    public class LibraryContext : ILibraryContext
+    {
+        public bool BindFiles { get; set; }
+
+        public IEnumerable<BindPath> BindPaths { get; set; }
+
+        public IEnumerable<ILibrarianExtension> Extensions { get; set; }
+
+        public IEnumerable<Localization> Localizations { get; set; }
+
+        public IEnumerable<Section> Sections { get; set; }
+
+        public IBindVariableResolver WixVariableResolver { get; set; }
+    }
+}
diff --git a/src/WixToolset.Core/Linker.cs b/src/WixToolset.Core/Linker.cs
index 1e5b6e96..c1c9f848 100644
--- a/src/WixToolset.Core/Linker.cs
+++ b/src/WixToolset.Core/Linker.cs
@@ -78,7 +78,7 @@ namespace WixToolset
         /// Gets or sets the Wix variable resolver.
         /// </summary>
         /// <value>The Wix variable resolver.</value>
-        public WixVariableResolver WixVariableResolver { get; set; }
+        internal IBindVariableResolver WixVariableResolver { get; set; }
 
         /// <summary>
         /// Adds an extension.
diff --git a/src/WixToolset.Core/Localizer.cs b/src/WixToolset.Core/Localizer.cs
index 63ead24a..72d0955b 100644
--- a/src/WixToolset.Core/Localizer.cs
+++ b/src/WixToolset.Core/Localizer.cs
@@ -8,11 +8,12 @@ namespace WixToolset
     using WixToolset.Data;
     using WixToolset.Data.Rows;
     using WixToolset.Core.Native;
+    using WixToolset.Extensibility;
 
     /// <summary>
     /// Parses localization files and localizes database values.
     /// </summary>
-    public sealed class Localizer
+    public sealed class Localizer : ILocalizer
     {
         public static readonly XNamespace WxlNamespace = "http://wixtoolset.org/schemas/v4/wxl";
         private static string XmlElementName = "WixLocalization";
@@ -55,7 +56,28 @@ namespace WixToolset
         /// Gets the codepage.
         /// </summary>
         /// <value>The codepage.</value>
-        public int Codepage { get; private set; }
+        public int Codepage { get; }
+
+        /// <summary>
+        /// Get a localized data value.
+        /// </summary>
+        /// <param name="id">The name of the localization variable.</param>
+        /// <returns>The localized data value or null if it wasn't found.</returns>
+        public string GetLocalizedValue(string id)
+        {
+            return this.variables.TryGetValue(id, out var wixVariableRow) ? wixVariableRow.Value : null;
+        }
+
+        /// <summary>
+        /// Get a localized control.
+        /// </summary>
+        /// <param name="dialog">The optional id of the control's dialog.</param>
+        /// <param name="control">The id of the control.</param>
+        /// <returns>The localized control or null if it wasn't found.</returns>
+        public LocalizedControl GetLocalizedControl(string dialog, string control)
+        {
+            return this.localizedControls.TryGetValue(LocalizedControl.GetKey(dialog, control), out var localizedControl) ? localizedControl : null;
+        }
 
         /// <summary>
         /// Loads a localization file from a path on disk.
@@ -97,36 +119,13 @@ namespace WixToolset
         }
 
         /// <summary>
-        /// Get a localized data value.
-        /// </summary>
-        /// <param name="id">The name of the localization variable.</param>
-        /// <returns>The localized data value or null if it wasn't found.</returns>
-        public string GetLocalizedValue(string id)
-        {
-            return this.variables.TryGetValue(id, out var wixVariableRow) ? wixVariableRow.Value : null;
-        }
-
-        /// <summary>
-        /// Get a localized control.
-        /// </summary>
-        /// <param name="dialog">The optional id of the control's dialog.</param>
-        /// <param name="control">The id of the control.</param>
-        /// <returns>The localized control or null if it wasn't found.</returns>
-        public LocalizedControl GetLocalizedControl(string dialog, string control)
-        {
-            LocalizedControl localizedControl;
-            return this.localizedControls.TryGetValue(LocalizedControl.GetKey(dialog, control), out localizedControl) ? localizedControl : null;
-        }
-
-        /// <summary>
         /// Adds a WixVariableRow to a dictionary while performing the expected override checks.
         /// </summary>
         /// <param name="variables">Dictionary of variable rows.</param>
         /// <param name="wixVariableRow">Row to add to the variables dictionary.</param>
         private static void AddWixVariable(IDictionary<string, WixVariableRow> variables, WixVariableRow wixVariableRow)
         {
-            WixVariableRow existingWixVariableRow;
-            if (!variables.TryGetValue(wixVariableRow.Id, out existingWixVariableRow) || (existingWixVariableRow.Overridable && !wixVariableRow.Overridable))
+            if (!variables.TryGetValue(wixVariableRow.Id, out var existingWixVariableRow) || (existingWixVariableRow.Overridable && !wixVariableRow.Overridable))
             {
                 variables[wixVariableRow.Id] = wixVariableRow;
             }
diff --git a/src/WixToolset.Core/OptimizeCA.cs b/src/WixToolset.Core/OptimizeCA.cs
new file mode 100644
index 00000000..efd07299
--- /dev/null
+++ b/src/WixToolset.Core/OptimizeCA.cs
@@ -0,0 +1,33 @@
+// 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
+{
+    using System;
+
+    /// <summary>
+    /// Values for the OptimizeCA MsiPatchMetdata property, which indicates whether custom actions can be skipped when applying the patch.
+    /// </summary>
+    [Flags]
+    public enum OptimizeCA
+    {
+        /// <summary>
+        /// No custom actions are skipped.
+        /// </summary>
+        None = 0,
+
+        /// <summary>
+        /// Skip property (type 51) and directory (type 35) assignment custom actions.
+        /// </summary>
+        SkipAssignment = 1,
+
+        /// <summary>
+        /// Skip immediate custom actions that are not property or directory assignment custom actions.
+        /// </summary>
+        SkipImmediate = 2,
+
+        /// <summary>
+        /// Skip custom actions that run within the script.
+        /// </summary>
+        SkipDeferred = 4,
+    }
+}
diff --git a/src/WixToolset.Core/PatchSymbolFlagsType.cs b/src/WixToolset.Core/PatchSymbolFlagsType.cs
new file mode 100644
index 00000000..eeb5c798
--- /dev/null
+++ b/src/WixToolset.Core/PatchSymbolFlagsType.cs
@@ -0,0 +1,19 @@
+// 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
+{
+    using System;
+
+    //
+    // The following flags are used with PATCH_OPTION_DATA SymbolOptionFlags:
+    //
+    [Flags]
+    public enum PatchSymbolFlagsType : uint
+    {
+        PATCH_SYMBOL_NO_IMAGEHLP = 0x00000001, // don't use imagehlp.dll
+        PATCH_SYMBOL_NO_FAILURES = 0x00000002, // don't fail patch due to imagehlp failures
+        PATCH_SYMBOL_UNDECORATED_TOO = 0x00000004, // after matching decorated symbols, try to match remaining by undecorated names
+        PATCH_SYMBOL_RESERVED1 = 0x80000000, // (used internally)
+        MaxValue = PATCH_SYMBOL_NO_IMAGEHLP | PATCH_SYMBOL_NO_FAILURES | PATCH_SYMBOL_UNDECORATED_TOO
+    }
+}
diff --git a/src/WixToolset.Core/PatchTransform.cs b/src/WixToolset.Core/PatchTransform.cs
index c87b1a21..46e4e6d7 100644
--- a/src/WixToolset.Core/PatchTransform.cs
+++ b/src/WixToolset.Core/PatchTransform.cs
@@ -155,7 +155,7 @@ namespace WixToolset
                             if (!deletedComponent.ContainsKey(componentId))
                             {
                                 bool foundRemoveFileEntry = false;
-                                string filename = Msi.Installer.GetName((string)row[2], false, true);
+                                string filename = Common.GetName((string)row[2], false, true);
 
                                 Table removeFileTable = this.Transform.Tables["RemoveFile"];
                                 if (null != removeFileTable)
@@ -172,7 +172,7 @@ namespace WixToolset
                                             // Check if there is a RemoveFile entry for this file
                                             if (null != removeFileRow[2])
                                             {
-                                                string removeFileName = Msi.Installer.GetName((string)removeFileRow[2], false, true);
+                                                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("|", "\\.");
diff --git a/src/WixToolset.Core/Properties/AssemblyInfo.cs b/src/WixToolset.Core/Properties/AssemblyInfo.cs
index b3740b2a..81274e3f 100644
--- a/src/WixToolset.Core/Properties/AssemblyInfo.cs
+++ b/src/WixToolset.Core/Properties/AssemblyInfo.cs
@@ -5,5 +5,5 @@ using System.Reflection;
 using System.Runtime.InteropServices;
 
 [assembly: AssemblyCulture("")]
-[assembly: CLSCompliant(true)]
+[assembly: CLSCompliant(false)]
 [assembly: ComVisible(false)]
diff --git a/src/WixToolset.Core/TransformsFlags.cs b/src/WixToolset.Core/TransformsFlags.cs
new file mode 100644
index 00000000..d9ec94ac
--- /dev/null
+++ b/src/WixToolset.Core/TransformsFlags.cs
@@ -0,0 +1,81 @@
+// 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
+{
+    using System;
+    using System.Diagnostics.CodeAnalysis;
+
+    /// <summary>
+    /// Summary information values for the CharCount property in transforms.
+    /// </summary>
+    [Flags]
+    [SuppressMessage("Microsoft.Naming", "CA1711:IdentifiersShouldNotHaveIncorrectSuffix")]
+    public enum TransformFlags
+    {
+        /// <summary>Ignore error when adding a row that exists.</summary>
+        ErrorAddExistingRow = 0x1,
+
+        /// <summary>Ignore error when deleting a row that does not exist.</summary>
+        ErrorDeleteMissingRow = 0x2,
+
+        /// <summary>Ignore error when adding a table that exists. </summary>
+        ErrorAddExistingTable = 0x4,
+
+        /// <summary>Ignore error when deleting a table that does not exist. </summary>
+        ErrorDeleteMissingTable = 0x8,
+
+        /// <summary>Ignore error when updating a row that does not exist. </summary>
+        ErrorUpdateMissingRow = 0x10,
+
+        /// <summary>Ignore error when transform and database code pages do not match, and their code pages are neutral.</summary>
+        ErrorChangeCodePage = 0x20,
+
+        /// <summary>Default language must match base database. </summary>
+        ValidateLanguage = 0x10000,
+
+        /// <summary>Product must match base database.</summary>
+        ValidateProduct = 0x20000,
+
+        /// <summary>Check major version only. </summary>
+        ValidateMajorVersion = 0x80000,
+
+        /// <summary>Check major and minor versions only. </summary>
+        ValidateMinorVersion = 0x100000,
+
+        /// <summary>Check major, minor, and update versions.</summary>
+        ValidateUpdateVersion = 0x200000,
+
+        /// <summary>Installed version lt base version. </summary>
+        ValidateNewLessBaseVersion = 0x400000,
+
+        /// <summary>Installed version lte base version. </summary>
+        ValidateNewLessEqualBaseVersion = 0x800000,
+
+        /// <summary>Installed version eq base version. </summary>
+        ValidateNewEqualBaseVersion = 0x1000000,
+
+        /// <summary>Installed version gte base version.</summary>
+        ValidateNewGreaterEqualBaseVersion = 0x2000000,
+
+        /// <summary>Installed version gt base version.</summary>
+        ValidateNewGreaterBaseVersion = 0x4000000,
+
+        /// <summary>UpgradeCode must match base database.</summary>
+        ValidateUpgradeCode = 0x8000000,
+
+        /// <summary>Masks all version checks on ProductVersion.</summary>
+        ProductVersionMask = ValidateMajorVersion | ValidateMinorVersion | ValidateUpdateVersion,
+
+        /// <summary>Masks all operations on ProductVersion.</summary>
+        ProductVersionOperatorMask = ValidateNewLessBaseVersion | ValidateNewLessEqualBaseVersion | ValidateNewEqualBaseVersion | ValidateNewGreaterEqualBaseVersion | ValidateNewGreaterBaseVersion,
+
+        /// <summary>Default value for instance transforms.</summary>
+        InstanceTransformDefault = ErrorAddExistingRow | ErrorDeleteMissingRow | ErrorAddExistingTable | ErrorDeleteMissingTable | ErrorUpdateMissingRow | ErrorChangeCodePage | ValidateProduct | ValidateUpdateVersion | ValidateNewGreaterEqualBaseVersion,
+
+        /// <summary>Default value for language transforms.</summary>
+        LanguageTransformDefault = ErrorAddExistingRow | ErrorDeleteMissingRow | ErrorAddExistingTable | ErrorDeleteMissingTable | ErrorUpdateMissingRow | ErrorChangeCodePage | ValidateProduct,
+
+        /// <summary>Default value for patch transforms.</summary>
+        PatchTransformDefault = ErrorAddExistingRow | ErrorDeleteMissingRow | ErrorAddExistingTable | ErrorDeleteMissingTable | ErrorUpdateMissingRow | ValidateProduct | ValidateUpdateVersion | ValidateNewEqualBaseVersion | ValidateUpgradeCode,
+    }
+}
diff --git a/src/WixToolset.Core/UnbindContext.cs b/src/WixToolset.Core/UnbindContext.cs
new file mode 100644
index 00000000..ed55f312
--- /dev/null
+++ b/src/WixToolset.Core/UnbindContext.cs
@@ -0,0 +1,24 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.Core
+{
+    using WixToolset.Data;
+    using WixToolset.Extensibility;
+
+    internal class UnbindContext : IUnbindContext
+    {
+        public Messaging Messaging { get; } = Messaging.Instance;
+
+        public string ExportBasePath { get; set; }
+
+        public string InputFilePath { get; set; }
+
+        public string IntermediateFolder { get; set; }
+
+        public bool IsAdminImage { get; set; }
+
+        public bool SuppressExtractCabinets { get; set; }
+
+        public bool SuppressDemodularization { get; set; }
+    }
+}
diff --git a/src/WixToolset.Core/Unbinder.cs b/src/WixToolset.Core/Unbinder.cs
index 744d5536..2ff51997 100644
--- a/src/WixToolset.Core/Unbinder.cs
+++ b/src/WixToolset.Core/Unbinder.cs
@@ -1,37 +1,18 @@
 // 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
+namespace WixToolset.Core
 {
-    using System;
-    using System.CodeDom.Compiler;
     using System.Collections;
-    using System.Collections.Generic;
-    using System.Collections.Specialized;
-    using System.ComponentModel;
-    using System.Globalization;
     using System.IO;
-    using System.Linq;
-    using System.Text.RegularExpressions;
-    using WixToolset.Bind;
-    using WixToolset.Bind.Bundles;
-    using WixToolset.Cab;
     using WixToolset.Data;
-    using WixToolset.Data.Rows;
     using WixToolset.Extensibility;
-    using WixToolset.Msi;
-    using WixToolset.Core.Native;
-    using WixToolset.Ole32;
+    using System.Collections.Generic;
 
     /// <summary>
     /// Unbinder core of the WiX toolset.
     /// </summary>
-    public sealed class Unbinder : IMessageHandler
+    public sealed class Unbinder
     {
-        private string emptyFile;
-        private bool isAdminImage;
-        private int sectionCount;
-        private bool suppressDemodularization;
-        private bool suppressExtractCabinets;
         private TableDefinitionCollection tableDefinitions;
         private ArrayList unbinderExtensions;
         // private TempFileCollection tempFiles;
@@ -45,61 +26,32 @@ namespace WixToolset
             this.unbinderExtensions = new ArrayList();
         }
 
+        public IEnumerable<IBackendFactory> BackendFactories { get; }
+
         /// <summary>
         /// Gets or sets whether the input msi is an admin image.
         /// </summary>
         /// <value>Set to true if the input msi is part of an admin image.</value>
-        public bool IsAdminImage
-        {
-            get { return this.isAdminImage; }
-            set { this.isAdminImage = value; }
-        }
+        public bool IsAdminImage { get; set; }
 
         /// <summary>
         /// Gets or sets the option to suppress demodularizing values.
         /// </summary>
         /// <value>The option to suppress demodularizing values.</value>
-        public bool SuppressDemodularization
-        {
-            get { return this.suppressDemodularization; }
-            set { this.suppressDemodularization = value; }
-        }
+        public bool SuppressDemodularization { get; set; }
 
         /// <summary>
         /// Gets or sets the option to suppress extracting cabinets.
         /// </summary>
         /// <value>The option to suppress extracting cabinets.</value>
-        public bool SuppressExtractCabinets
-        {
-            get { return this.suppressExtractCabinets; }
-            set { this.suppressExtractCabinets = value; }
-        }
+        public bool SuppressExtractCabinets { get; set; }
 
         /// <summary>
         /// Gets or sets the temporary path for the Binder.  If left null, the binder
         /// will use %TEMP% environment variable.
         /// </summary>
         /// <value>Path to temp files.</value>
-        public string TempFilesLocation
-        {
-            get
-            {
-                // return null == this.tempFiles ? String.Empty : this.tempFiles.BasePath;
-                return Path.GetTempPath();
-            }
-
-            // set
-            // {
-            //     if (null == value)
-            //     {
-            //         this.tempFiles = new TempFileCollection();
-            //     }
-            //     else
-            //     {
-            //         this.tempFiles = new TempFileCollection(value);
-            //     }
-            // }
-        }
+        public string TempFilesLocation => Path.GetTempPath();
 
         /// <summary>
         /// Adds extension data.
@@ -156,1336 +108,25 @@ namespace WixToolset
             // if we don't have the temporary files object yet, get one
             Directory.CreateDirectory(this.TempFilesLocation); // ensure the base path is there
 
-            if (OutputType.Patch == outputType)
-            {
-                return this.UnbindPatch(file, exportBasePath);
-            }
-            else if (OutputType.Transform == outputType)
-            {
-                return this.UnbindTransform(file, exportBasePath);
-            }
-            else if (OutputType.Bundle == outputType)
-            {
-                return this.UnbindBundle(file, exportBasePath);
-            }
-            else // other database types
-            {
-                return this.UnbindDatabase(file, outputType, exportBasePath);
-            }
-        }
-
-        /// <summary>
-        /// Cleans up the temp files used by the Decompiler.
-        /// </summary>
-        /// <returns>True if all files were deleted, false otherwise.</returns>
-        /// <remarks>
-        /// This should be called after every call to Decompile to ensure there
-        /// are no conflicts between each decompiled database.
-        /// </remarks>
-        public bool DeleteTempFiles()
-        {
-#if REDO_IN_NETCORE
-            bool deleted = Common.DeleteTempFiles(this.tempFiles.BasePath, this);
-
-            if (deleted)
-            {
-                this.tempFiles = null; // temp files have been deleted, no need to remember this now
-            }
-
-            return deleted;
-#endif
-            return true;
-        }
-
-        /// <summary>
-        /// Sends a message to the message delegate if there is one.
-        /// </summary>
-        /// <param name="mea">Message event arguments.</param>
-        public void OnMessage(MessageEventArgs e)
-        {
-            Messaging.Instance.OnMessage(e);
-        }
-
-        /// <summary>
-        /// Unbind an MSI database file.
-        /// </summary>
-        /// <param name="databaseFile">The database file.</param>
-        /// <param name="outputType">The output type.</param>
-        /// <param name="exportBasePath">The path where files should be exported.</param>
-        /// <returns>The unbound database.</returns>
-        private Output UnbindDatabase(string databaseFile, OutputType outputType, string exportBasePath)
-        {
-            Output output;
-
-            try
-            {
-                using (Database database = new Database(databaseFile, OpenDatabase.ReadOnly))
-                {
-                    output = this.UnbindDatabase(databaseFile, database, outputType, exportBasePath, false);
-
-                    // extract the files from the cabinets
-                    if (null != exportBasePath && !this.suppressExtractCabinets)
-                    {
-                        this.ExtractCabinets(output, database, databaseFile, exportBasePath);
-                    }
-                }
-            }
-            catch (Win32Exception e)
-            {
-                if (0x6E == e.NativeErrorCode) // ERROR_OPEN_FAILED
-                {
-                    throw new WixException(WixErrors.OpenDatabaseFailed(databaseFile));
-                }
-
-                throw;
-            }
-
-            return output;
-        }
-
-        /// <summary>
-        /// Unbind an MSI database file.
-        /// </summary>
-        /// <param name="databaseFile">The database file.</param>
-        /// <param name="database">The opened database.</param>
-        /// <param name="outputType">The type of output to create.</param>
-        /// <param name="exportBasePath">The path where files should be exported.</param>
-        /// <param name="skipSummaryInfo">Option to skip unbinding the _SummaryInformation table.</param>
-        /// <returns>The output representing the database.</returns>
-        private Output UnbindDatabase(string databaseFile, Database database, OutputType outputType, string exportBasePath, bool skipSummaryInfo)
-        {
-            string modularizationGuid = null;
-            Output output = new Output(new SourceLineNumber(databaseFile));
-            View validationView = null;
-
-            // set the output type
-            output.Type = outputType;
-
-            // get the codepage
-            database.Export("_ForceCodepage", this.TempFilesLocation, "_ForceCodepage.idt");
-            using (StreamReader sr = File.OpenText(Path.Combine(this.TempFilesLocation, "_ForceCodepage.idt")))
-            {
-                string line;
-
-                while (null != (line = sr.ReadLine()))
-                {
-                    string[] data = line.Split('\t');
-
-                    if (2 == data.Length)
-                    {
-                        output.Codepage = Convert.ToInt32(data[0], CultureInfo.InvariantCulture);
-                    }
-                }
-            }
-
-            // get the summary information table if it exists; it won't if unbinding a transform
-            if (!skipSummaryInfo)
-            {
-                using (SummaryInformation summaryInformation = new SummaryInformation(database))
-                {
-                    Table table = new Table(null, this.tableDefinitions["_SummaryInformation"]);
-
-                    for (int i = 1; 19 >= i; i++)
-                    {
-                        string value = summaryInformation.GetProperty(i);
-
-                        if (0 < value.Length)
-                        {
-                            Row row = table.CreateRow(output.SourceLineNumbers);
-                            row[0] = i;
-                            row[1] = value;
-                        }
-                    }
-
-                    output.Tables.Add(table);
-                }
-            }
-
-            try
-            {
-                // open a view on the validation table if it exists
-                if (database.TableExists("_Validation"))
-                {
-                    validationView = database.OpenView("SELECT * FROM `_Validation` WHERE `Table` = ? AND `Column` = ?");
-                }
-
-                // get the normal tables
-                using (View tablesView = database.OpenExecuteView("SELECT * FROM _Tables"))
-                {
-                    while (true)
-                    {
-                        using (Record tableRecord = tablesView.Fetch())
-                        {
-                            if (null == tableRecord)
-                            {
-                                break;
-                            }
-
-                            string tableName = tableRecord.GetString(1);
-
-                            using (View tableView = database.OpenExecuteView(String.Format(CultureInfo.InvariantCulture, "SELECT * FROM `{0}`", tableName)))
-                            {
-                                List<ColumnDefinition> columns;
-                                using (Record columnNameRecord = tableView.GetColumnInfo(MsiInterop.MSICOLINFONAMES),
-                                              columnTypeRecord = tableView.GetColumnInfo(MsiInterop.MSICOLINFOTYPES))
-                                {
-                                    // index the primary keys
-                                    HashSet<string> tablePrimaryKeys = new HashSet<string>();
-                                    using (Record primaryKeysRecord = database.PrimaryKeys(tableName))
-                                    {
-                                        int primaryKeysFieldCount = primaryKeysRecord.GetFieldCount();
-
-                                        for (int i = 1; i <= primaryKeysFieldCount; i++)
-                                        {
-                                            tablePrimaryKeys.Add(primaryKeysRecord.GetString(i));
-                                        }
-                                    }
-
-                                    int columnCount = columnNameRecord.GetFieldCount();
-                                    columns = new List<ColumnDefinition>(columnCount);
-                                    for (int i = 1; i <= columnCount; i++)
-                                    {
-                                        string columnName = columnNameRecord.GetString(i);
-                                        string idtType = columnTypeRecord.GetString(i);
-
-                                        ColumnType columnType;
-                                        int length;
-                                        bool nullable;
-
-                                        ColumnCategory columnCategory = ColumnCategory.Unknown;
-                                        ColumnModularizeType columnModularizeType = ColumnModularizeType.None;
-                                        bool primary = tablePrimaryKeys.Contains(columnName);
-                                        bool minValueSet = false;
-                                        int minValue = -1;
-                                        bool maxValueSet = false;
-                                        int maxValue = -1;
-                                        string keyTable = null;
-                                        bool keyColumnSet = false;
-                                        int keyColumn = -1;
-                                        string category = null;
-                                        string set = null;
-                                        string description = null;
-
-                                        // get the column type, length, and whether its nullable
-                                        switch (Char.ToLower(idtType[0], CultureInfo.InvariantCulture))
-                                        {
-                                            case 'i':
-                                                columnType = ColumnType.Number;
-                                                break;
-                                            case 'l':
-                                                columnType = ColumnType.Localized;
-                                                break;
-                                            case 's':
-                                                columnType = ColumnType.String;
-                                                break;
-                                            case 'v':
-                                                columnType = ColumnType.Object;
-                                                break;
-                                            default:
-                                                // TODO: error
-                                                columnType = ColumnType.Unknown;
-                                                break;
-                                        }
-                                        length = Convert.ToInt32(idtType.Substring(1), CultureInfo.InvariantCulture);
-                                        nullable = Char.IsUpper(idtType[0]);
-
-                                        // try to get validation information
-                                        if (null != validationView)
-                                        {
-                                            using (Record validationRecord = new Record(2))
-                                            {
-                                                validationRecord.SetString(1, tableName);
-                                                validationRecord.SetString(2, columnName);
-
-                                                validationView.Execute(validationRecord);
-                                            }
-
-                                            using (Record validationRecord = validationView.Fetch())
-                                            {
-                                                if (null != validationRecord)
-                                                {
-                                                    string validationNullable = validationRecord.GetString(3);
-                                                    minValueSet = !validationRecord.IsNull(4);
-                                                    minValue = (minValueSet ? validationRecord.GetInteger(4) : -1);
-                                                    maxValueSet = !validationRecord.IsNull(5);
-                                                    maxValue = (maxValueSet ? validationRecord.GetInteger(5) : -1);
-                                                    keyTable = (!validationRecord.IsNull(6) ? validationRecord.GetString(6) : null);
-                                                    keyColumnSet = !validationRecord.IsNull(7);
-                                                    keyColumn = (keyColumnSet ? validationRecord.GetInteger(7) : -1);
-                                                    category = (!validationRecord.IsNull(8) ? validationRecord.GetString(8) : null);
-                                                    set = (!validationRecord.IsNull(9) ? validationRecord.GetString(9) : null);
-                                                    description = (!validationRecord.IsNull(10) ? validationRecord.GetString(10) : null);
-
-                                                    // check the validation nullable value against the column definition
-                                                    if (null == validationNullable)
-                                                    {
-                                                        // TODO: warn for illegal validation nullable column
-                                                    }
-                                                    else if ((nullable && "Y" != validationNullable) || (!nullable && "N" != validationNullable))
-                                                    {
-                                                        // TODO: warn for mismatch between column definition and validation nullable
-                                                    }
-
-                                                    // convert category to ColumnCategory
-                                                    if (null != category)
-                                                    {
-                                                        try
-                                                        {
-                                                            columnCategory = (ColumnCategory)Enum.Parse(typeof(ColumnCategory), category, true);
-                                                        }
-                                                        catch (ArgumentException)
-                                                        {
-                                                            columnCategory = ColumnCategory.Unknown;
-                                                        }
-                                                    }
-                                                }
-                                                else
-                                                {
-                                                    // TODO: warn about no validation information
-                                                }
-                                            }
-                                        }
-
-                                        // guess the modularization type
-                                        if ("Icon" == keyTable && 1 == keyColumn)
-                                        {
-                                            columnModularizeType = ColumnModularizeType.Icon;
-                                        }
-                                        else if ("Condition" == columnName)
-                                        {
-                                            columnModularizeType = ColumnModularizeType.Condition;
-                                        }
-                                        else if (ColumnCategory.Formatted == columnCategory || ColumnCategory.FormattedSDDLText == columnCategory)
-                                        {
-                                            columnModularizeType = ColumnModularizeType.Property;
-                                        }
-                                        else if (ColumnCategory.Identifier == columnCategory)
-                                        {
-                                            columnModularizeType = ColumnModularizeType.Column;
-                                        }
-
-                                        columns.Add(new ColumnDefinition(columnName, columnType, length, primary, nullable, columnModularizeType, (ColumnType.Localized == columnType), minValueSet, minValue, maxValueSet, maxValue, keyTable, keyColumnSet, keyColumn, columnCategory, set, description, true, true));
-                                    }
-                                }
-
-                                TableDefinition tableDefinition = new TableDefinition(tableName, columns, false, false);
-
-                                // use our table definitions if core properties are the same; this allows us to take advantage
-                                // of wix concepts like localizable columns which current code assumes
-                                if (this.tableDefinitions.Contains(tableName) && 0 == tableDefinition.CompareTo(this.tableDefinitions[tableName]))
-                                {
-                                    tableDefinition = this.tableDefinitions[tableName];
-                                }
-
-                                Table table = new Table(null, tableDefinition);
-
-                                while (true)
-                                {
-                                    using (Record rowRecord = tableView.Fetch())
-                                    {
-                                        if (null == rowRecord)
-                                        {
-                                            break;
-                                        }
-
-                                        int recordCount = rowRecord.GetFieldCount();
-                                        Row row = table.CreateRow(output.SourceLineNumbers);
-
-                                        for (int i = 0; recordCount > i && row.Fields.Length > i; i++)
-                                        {
-                                            if (rowRecord.IsNull(i + 1))
-                                            {
-                                                if (!row.Fields[i].Column.Nullable)
-                                                {
-                                                    // TODO: display an error for a null value in a non-nullable field OR
-                                                    // display a warning and put an empty string in the value to let the compiler handle it
-                                                    // (the second option is risky because the later code may make certain assumptions about
-                                                    // the contents of a row value)
-                                                }
-                                            }
-                                            else
-                                            {
-                                                switch (row.Fields[i].Column.Type)
-                                                {
-                                                    case ColumnType.Number:
-                                                        bool success = false;
-                                                        int intValue = rowRecord.GetInteger(i + 1);
-                                                        if (row.Fields[i].Column.IsLocalizable)
-                                                        {
-                                                            success = row.BestEffortSetField(i, Convert.ToString(intValue, CultureInfo.InvariantCulture));
-                                                        }
-                                                        else
-                                                        {
-                                                            success = row.BestEffortSetField(i, intValue);
-                                                        }
-
-                                                        if (!success)
-                                                        {
-                                                            this.OnMessage(WixWarnings.BadColumnDataIgnored(row.SourceLineNumbers, Convert.ToString(intValue, CultureInfo.InvariantCulture), tableName, row.Fields[i].Column.Name));
-                                                        }
-                                                        break;
-                                                    case ColumnType.Object:
-                                                        string sourceFile = "FILE NOT EXPORTED, USE THE dark.exe -x OPTION TO EXPORT BINARIES";
-
-                                                        if (null != exportBasePath)
-                                                        {
-                                                            string relativeSourceFile = Path.Combine(tableName, row.GetPrimaryKey('.'));
-                                                            sourceFile = Path.Combine(exportBasePath, relativeSourceFile);
-
-                                                            // ensure the parent directory exists
-                                                            System.IO.Directory.CreateDirectory(Path.Combine(exportBasePath, tableName));
-
-                                                            using (FileStream fs = System.IO.File.Create(sourceFile))
-                                                            {
-                                                                int bytesRead;
-                                                                byte[] buffer = new byte[512];
-
-                                                                while (0 != (bytesRead = rowRecord.GetStream(i + 1, buffer, buffer.Length)))
-                                                                {
-                                                                    fs.Write(buffer, 0, bytesRead);
-                                                                }
-                                                            }
-                                                        }
-
-                                                        row[i] = sourceFile;
-                                                        break;
-                                                    default:
-                                                        string value = rowRecord.GetString(i + 1);
+            var context = new UnbindContext();
+            context.InputFilePath = file;
+            context.ExportBasePath = exportBasePath;
+            context.IntermediateFolder = this.TempFilesLocation;
+            context.IsAdminImage = this.IsAdminImage;
+            context.SuppressDemodularization = this.SuppressDemodularization;
+            context.SuppressExtractCabinets = this.SuppressExtractCabinets;
 
-                                                        switch (row.Fields[i].Column.Category)
-                                                        {
-                                                            case ColumnCategory.Guid:
-                                                                value = value.ToUpper(CultureInfo.InvariantCulture);
-                                                                break;
-                                                        }
-
-                                                        // de-modularize
-                                                        if (!this.suppressDemodularization && OutputType.Module == output.Type && ColumnModularizeType.None != row.Fields[i].Column.ModularizeType)
-                                                        {
-                                                            Regex modularization = new Regex(@"\.[0-9A-Fa-f]{8}_[0-9A-Fa-f]{4}_[0-9A-Fa-f]{4}_[0-9A-Fa-f]{4}_[0-9A-Fa-f]{12}");
-
-                                                            if (null == modularizationGuid)
-                                                            {
-                                                                Match match = modularization.Match(value);
-                                                                if (match.Success)
-                                                                {
-                                                                    modularizationGuid = String.Concat('{', match.Value.Substring(1).Replace('_', '-'), '}');
-                                                                }
-                                                            }
-
-                                                            value = modularization.Replace(value, String.Empty);
-                                                        }
-
-                                                        // escape "$(" for the preprocessor
-                                                        value = value.Replace("$(", "$$(");
-
-                                                        // escape things that look like wix variables
-                                                        MatchCollection matches = Common.WixVariableRegex.Matches(value);
-                                                        for (int j = matches.Count - 1; 0 <= j; j--)
-                                                        {
-                                                            value = value.Insert(matches[j].Index, "!");
-                                                        }
-
-                                                        row[i] = value;
-                                                        break;
-                                                }
-                                            }
-                                        }
-                                    }
-                                }
-
-                                output.Tables.Add(table);
-                            }
-
-                        }
-                    }
-                }
-            }
-            finally
-            {
-                if (null != validationView)
-                {
-                    validationView.Close();
-                }
-            }
-
-            // set the modularization guid as the PackageCode
-            if (null != modularizationGuid)
+            foreach (var factory in this.BackendFactories)
             {
-                Table table = output.Tables["_SummaryInformation"];
-
-                foreach (Row row in table.Rows)
+                if (factory.TryCreateBackend(outputType.ToString(), file, null, out var backend))
                 {
-                    if (9 == (int)row[0]) // PID_REVNUMBER
-                    {
-                        row[1] = modularizationGuid;
-                    }
+                    return backend.Unbind(context);
                 }
             }
 
-            if (this.isAdminImage)
-            {
-                GenerateWixFileTable(databaseFile, output);
-                GenerateSectionIds(output);
-            }
-
-            return output;
-        }
-
-        /// <summary>
-        /// Creates section ids on rows which form logical groupings of resources.
-        /// </summary>
-        /// <param name="output">The Output that represents the msi database.</param>
-        private void GenerateSectionIds(Output output)
-        {
-            // First assign and index section ids for the tables that are in their own sections.
-            AssignSectionIdsToTable(output.Tables["Binary"], 0);
-            Hashtable componentSectionIdIndex = AssignSectionIdsToTable(output.Tables["Component"], 0);
-            Hashtable customActionSectionIdIndex = AssignSectionIdsToTable(output.Tables["CustomAction"], 0);
-            AssignSectionIdsToTable(output.Tables["Directory"], 0);
-            Hashtable featureSectionIdIndex = AssignSectionIdsToTable(output.Tables["Feature"], 0);
-            AssignSectionIdsToTable(output.Tables["Icon"], 0);
-            Hashtable digitalCertificateSectionIdIndex = AssignSectionIdsToTable(output.Tables["MsiDigitalCertificate"], 0);
-            AssignSectionIdsToTable(output.Tables["Property"], 0);
-
-            // Now handle all the tables that rely on the first set of indexes but also produce their own indexes. Order matters here.
-            Hashtable fileSectionIdIndex = ConnectTableToSectionAndIndex(output.Tables["File"], componentSectionIdIndex, 1, 0);
-            Hashtable appIdSectionIdIndex = ConnectTableToSectionAndIndex(output.Tables["Class"], componentSectionIdIndex, 2, 5);
-            Hashtable odbcDataSourceSectionIdIndex = ConnectTableToSectionAndIndex(output.Tables["ODBCDataSource"], componentSectionIdIndex, 1, 0);
-            Hashtable odbcDriverSectionIdIndex = ConnectTableToSectionAndIndex(output.Tables["ODBCDriver"], componentSectionIdIndex, 1, 0);
-            Hashtable registrySectionIdIndex = ConnectTableToSectionAndIndex(output.Tables["Registry"], componentSectionIdIndex, 5, 0);
-            Hashtable serviceInstallSectionIdIndex = ConnectTableToSectionAndIndex(output.Tables["ServiceInstall"], componentSectionIdIndex, 11, 0);
-
-            // Now handle all the tables which only rely on previous indexes and order does not matter.
-            foreach (Table table in output.Tables)
-            {
-                switch (table.Name)
-                {
-                    case "WixFile":
-                    case "MsiFileHash":
-                        ConnectTableToSection(table, fileSectionIdIndex, 0);
-                        break;
-                    case "MsiAssembly":
-                    case "MsiAssemblyName":
-                        ConnectTableToSection(table, componentSectionIdIndex, 0);
-                        break;
-                    case "MsiPackageCertificate":
-                    case "MsiPatchCertificate":
-                        ConnectTableToSection(table, digitalCertificateSectionIdIndex, 1);
-                        break;
-                    case "CreateFolder":
-                    case "FeatureComponents":
-                    case "MoveFile":
-                    case "ReserveCost":
-                    case "ODBCTranslator":
-                        ConnectTableToSection(table, componentSectionIdIndex, 1);
-                        break;
-                    case "TypeLib":
-                        ConnectTableToSection(table, componentSectionIdIndex, 2);
-                        break;
-                    case "Shortcut":
-                    case "Environment":
-                        ConnectTableToSection(table, componentSectionIdIndex, 3);
-                        break;
-                    case "RemoveRegistry":
-                        ConnectTableToSection(table, componentSectionIdIndex, 4);
-                        break;
-                    case "ServiceControl":
-                        ConnectTableToSection(table, componentSectionIdIndex, 5);
-                        break;
-                    case "IniFile":
-                    case "RemoveIniFile":
-                        ConnectTableToSection(table, componentSectionIdIndex, 7);
-                        break;
-                    case "AppId":
-                        ConnectTableToSection(table, appIdSectionIdIndex, 0);
-                        break;
-                    case "Condition":
-                        ConnectTableToSection(table, featureSectionIdIndex, 0);
-                        break;
-                    case "ODBCSourceAttribute":
-                        ConnectTableToSection(table, odbcDataSourceSectionIdIndex, 0);
-                        break;
-                    case "ODBCAttribute":
-                        ConnectTableToSection(table, odbcDriverSectionIdIndex, 0);
-                        break;
-                    case "AdminExecuteSequence":
-                    case "AdminUISequence":
-                    case "AdvtExecuteSequence":
-                    case "AdvtUISequence":
-                    case "InstallExecuteSequence":
-                    case "InstallUISequence":
-                        ConnectTableToSection(table, customActionSectionIdIndex, 0);
-                        break;
-                    case "LockPermissions":
-                    case "MsiLockPermissions":
-                        foreach (Row row in table.Rows)
-                        {
-                            string lockObject = (string)row[0];
-                            string tableName = (string)row[1];
-                            switch (tableName)
-                            {
-                                case "File":
-                                    row.SectionId = (string)fileSectionIdIndex[lockObject];
-                                    break;
-                                case "Registry":
-                                    row.SectionId = (string)registrySectionIdIndex[lockObject];
-                                    break;
-                                case "ServiceInstall":
-                                    row.SectionId = (string)serviceInstallSectionIdIndex[lockObject];
-                                    break;
-                            }
-                        }
-                        break;
-                }
-            }
-
-            // Now pass the output to each unbinder extension to allow them to analyze the output and determine thier proper section ids.
-            foreach (IUnbinderExtension extension in this.unbinderExtensions)
-            {
-                extension.GenerateSectionIds(output);
-            }
-        }
-
-        /// <summary>
-        /// Creates new section ids on all the rows in a table.
-        /// </summary>
-        /// <param name="table">The table to add sections to.</param>
-        /// <param name="rowPrimaryKeyIndex">The index of the column which is used by other tables to reference this table.</param>
-        /// <returns>A Hashtable containing the tables key for each row paired with its assigned section id.</returns>
-        private Hashtable AssignSectionIdsToTable(Table table, int rowPrimaryKeyIndex)
-        {
-            Hashtable hashtable = new Hashtable();
-            if (null != table)
-            {
-                foreach (Row row in table.Rows)
-                {
-                    row.SectionId = GetNewSectionId();
-                    hashtable.Add(row[rowPrimaryKeyIndex], row.SectionId);
-                }
-            }
-            return hashtable;
-        }
-
-        /// <summary>
-        /// Connects a table's rows to an already sectioned table.
-        /// </summary>
-        /// <param name="table">The table containing rows that need to be connected to sections.</param>
-        /// <param name="sectionIdIndex">A hashtable containing keys to map table to its section.</param>
-        /// <param name="rowIndex">The index of the column which is used as the foreign key in to the sectionIdIndex.</param>
-        private static void ConnectTableToSection(Table table, Hashtable sectionIdIndex, int rowIndex)
-        {
-            if (null != table)
-            {
-                foreach (Row row in table.Rows)
-                {
-                    if (sectionIdIndex.ContainsKey(row[rowIndex]))
-                    {
-                        row.SectionId = (string)sectionIdIndex[row[rowIndex]];
-                    }
-                }
-            }
-        }
-
-        /// <summary>
-        /// Connects a table's rows to an already sectioned table and produces an index for other tables to connect to it.
-        /// </summary>
-        /// <param name="table">The table containing rows that need to be connected to sections.</param>
-        /// <param name="sectionIdIndex">A hashtable containing keys to map table to its section.</param>
-        /// <param name="rowIndex">The index of the column which is used as the foreign key in to the sectionIdIndex.</param>
-        /// <param name="rowPrimaryKeyIndex">The index of the column which is used by other tables to reference this table.</param>
-        /// <returns>A Hashtable containing the tables key for each row paired with its assigned section id.</returns>
-        private static Hashtable ConnectTableToSectionAndIndex(Table table, Hashtable sectionIdIndex, int rowIndex, int rowPrimaryKeyIndex)
-        {
-            Hashtable newHashTable = new Hashtable();
-            if (null != table)
-            {
-                foreach (Row row in table.Rows)
-                {
-                    if (!sectionIdIndex.ContainsKey(row[rowIndex]))
-                    {
-                        continue;
-                    }
-
-                    row.SectionId = (string)sectionIdIndex[row[rowIndex]];
-                    if (null != row[rowPrimaryKeyIndex])
-                    {
-                        newHashTable.Add(row[rowPrimaryKeyIndex], row.SectionId);
-                    }
-                }
-            }
-            return newHashTable;
-        }
-
-        /// <summary>
-        /// Creates a new section identifier to be used when adding a section to an output.
-        /// </summary>
-        /// <returns>A string representing a new section id.</returns>
-        private string GetNewSectionId()
-        {
-            this.sectionCount++;
-            return "wix.section." + this.sectionCount.ToString(CultureInfo.InvariantCulture);
-        }
-
-        /// <summary>
-        /// Generates the WixFile table based on a path to an admin image msi and an Output.
-        /// </summary>
-        /// <param name="databaseFile">The path to the msi database file in an admin image.</param>
-        /// <param name="output">The Output that represents the msi database.</param>
-        private void GenerateWixFileTable(string databaseFile, Output output)
-        {
-            string adminRootPath = Path.GetDirectoryName(databaseFile);
-
-            Hashtable componentDirectoryIndex = new Hashtable();
-            Table componentTable = output.Tables["Component"];
-            foreach (Row row in componentTable.Rows)
-            {
-                componentDirectoryIndex.Add(row[0], row[2]);
-            }
-
-            // Index full source paths for all directories
-            Hashtable directoryDirectoryParentIndex = new Hashtable();
-            Hashtable directoryFullPathIndex = new Hashtable();
-            Hashtable directorySourceNameIndex = new Hashtable();
-            Table directoryTable = output.Tables["Directory"];
-            foreach (Row row in directoryTable.Rows)
-            {
-                directoryDirectoryParentIndex.Add(row[0], row[1]);
-                if (null == row[1])
-                {
-                    directoryFullPathIndex.Add(row[0], adminRootPath);
-                }
-                else
-                {
-                    directorySourceNameIndex.Add(row[0], GetAdminSourceName((string)row[2]));
-                }
-            }
-
-            foreach (DictionaryEntry directoryEntry in directoryDirectoryParentIndex)
-            {
-                if (!directoryFullPathIndex.ContainsKey(directoryEntry.Key))
-                {
-                    GetAdminFullPath((string)directoryEntry.Key, directoryDirectoryParentIndex, directorySourceNameIndex, directoryFullPathIndex);
-                }
-            }
-
-            Table fileTable = output.Tables["File"];
-            Table wixFileTable = output.EnsureTable(this.tableDefinitions["WixFile"]);
-            foreach (Row row in fileTable.Rows)
-            {
-                WixFileRow wixFileRow = new WixFileRow(null, this.tableDefinitions["WixFile"]);
-                wixFileRow.File = (string)row[0];
-                wixFileRow.Directory = (string)componentDirectoryIndex[(string)row[1]];
-                wixFileRow.Source = Path.Combine((string)directoryFullPathIndex[wixFileRow.Directory], GetAdminSourceName((string)row[2]));
-
-                if (!File.Exists(wixFileRow.Source))
-                {
-                    throw new WixException(WixErrors.WixFileNotFound(wixFileRow.Source));
-                }
-
-                wixFileTable.Rows.Add(wixFileRow);
-            }
-        }
-
-        /// <summary>
-        /// Gets the full path of a directory. Populates the full path index with the directory's full path and all of its parent directorie's full paths.
-        /// </summary>
-        /// <param name="directory">The directory identifier.</param>
-        /// <param name="directoryDirectoryParentIndex">The Hashtable containing all the directory to directory parent mapping.</param>
-        /// <param name="directorySourceNameIndex">The Hashtable containing all the directory to source name mapping.</param>
-        /// <param name="directoryFullPathIndex">The Hashtable containing a mapping between all of the directories and their previously calculated full paths.</param>
-        /// <returns>The full path to the directory.</returns>
-        private string GetAdminFullPath(string directory, Hashtable directoryDirectoryParentIndex, Hashtable directorySourceNameIndex, Hashtable directoryFullPathIndex)
-        {
-            string parent = (string)directoryDirectoryParentIndex[directory];
-            string sourceName = (string)directorySourceNameIndex[directory];
-
-            string parentFullPath;
-            if (directoryFullPathIndex.ContainsKey(parent))
-            {
-                parentFullPath = (string)directoryFullPathIndex[parent];
-            }
-            else
-            {
-                parentFullPath = GetAdminFullPath(parent, directoryDirectoryParentIndex, directorySourceNameIndex, directoryFullPathIndex);
-            }
-
-            if (null == sourceName)
-            {
-                sourceName = String.Empty;
-            }
-
-            string fullPath = Path.Combine(parentFullPath, sourceName);
-            directoryFullPathIndex.Add(directory, fullPath);
-
-            return fullPath;
-        }
-
-        /// <summary>
-        /// Get the source name in an admin image.
-        /// </summary>
-        /// <param name="value">The Filename value.</param>
-        /// <returns>The source name of the directory in an admin image.</returns>
-        private static string GetAdminSourceName(string value)
-        {
-            string name = null;
-            string[] names;
-            string shortname = null;
-            string shortsourcename = null;
-            string sourcename = null;
-
-            names = Installer.GetNames(value);
-
-            if (null != names[0] && "." != names[0])
-            {
-                if (null != names[1])
-                {
-                    shortname = names[0];
-                }
-                else
-                {
-                    name = names[0];
-                }
-            }
-
-            if (null != names[1])
-            {
-                name = names[1];
-            }
-
-            if (null != names[2])
-            {
-                if (null != names[3])
-                {
-                    shortsourcename = names[2];
-                }
-                else
-                {
-                    sourcename = names[2];
-                }
-            }
-
-            if (null != names[3])
-            {
-                sourcename = names[3];
-            }
-
-            if (null != sourcename)
-            {
-                return sourcename;
-            }
-            else if (null != shortsourcename)
-            {
-                return shortsourcename;
-            }
-            else if (null != name)
-            {
-                return name;
-            }
-            else
-            {
-                return shortname;
-            }
-        }
-
-        /// <summary>
-        /// Unbind an MSP patch file.
-        /// </summary>
-        /// <param name="patchFile">The patch file.</param>
-        /// <param name="exportBasePath">The path where files should be exported.</param>
-        /// <returns>The unbound patch.</returns>
-        private Output UnbindPatch(string patchFile, string exportBasePath)
-        {
-            Output patch;
-
-            // patch files are essentially database files (use a special flag to let the API know its a patch file)
-            try
-            {
-                using (Database database = new Database(patchFile, OpenDatabase.ReadOnly | OpenDatabase.OpenPatchFile))
-                {
-                    patch = this.UnbindDatabase(patchFile, database, OutputType.Patch, exportBasePath, false);
-                }
-            }
-            catch (Win32Exception e)
-            {
-                if (0x6E == e.NativeErrorCode) // ERROR_OPEN_FAILED
-                {
-                    throw new WixException(WixErrors.OpenDatabaseFailed(patchFile));
-                }
-
-                throw;
-            }
-
-            // retrieve the transforms (they are in substorages)
-            using (Storage storage = Storage.Open(patchFile, StorageMode.Read | StorageMode.ShareDenyWrite))
-            {
-                Table summaryInformationTable = patch.Tables["_SummaryInformation"];
-                foreach (Row row in summaryInformationTable.Rows)
-                {
-                    if (8 == (int)row[0]) // PID_LASTAUTHOR
-                    {
-                        string value = (string)row[1];
-
-                        foreach (string decoratedSubStorageName in value.Split(';'))
-                        {
-                            string subStorageName = decoratedSubStorageName.Substring(1);
-                            string transformFile = Path.Combine(this.TempFilesLocation, String.Concat("Transform", Path.DirectorySeparatorChar, subStorageName, ".mst"));
-
-                            // ensure the parent directory exists
-                            System.IO.Directory.CreateDirectory(Path.GetDirectoryName(transformFile));
-
-                            // copy the substorage to a new storage for the transform file
-                            using (Storage subStorage = storage.OpenStorage(subStorageName))
-                            {
-                                using (Storage transformStorage = Storage.CreateDocFile(transformFile, StorageMode.ReadWrite | StorageMode.ShareExclusive | StorageMode.Create))
-                                {
-                                    subStorage.CopyTo(transformStorage);
-                                }
-                            }
-
-                            // unbind the transform
-                            Output transform = this.UnbindTransform(transformFile, (null == exportBasePath ? null : Path.Combine(exportBasePath, subStorageName)));
-                            patch.SubStorages.Add(new SubStorage(subStorageName, transform));
-                        }
-
-                        break;
-                    }
-                }
-            }
-
-            // extract the files from the cabinets
-            // TODO: use per-transform export paths for support of multi-product patches
-            if (null != exportBasePath && !this.suppressExtractCabinets)
-            {
-                using (Database database = new Database(patchFile, OpenDatabase.ReadOnly | OpenDatabase.OpenPatchFile))
-                {
-                    foreach (SubStorage subStorage in patch.SubStorages)
-                    {
-                        // only patch transforms should carry files
-                        if (subStorage.Name.StartsWith("#", StringComparison.Ordinal))
-                        {
-                            this.ExtractCabinets(subStorage.Data, database, patchFile, exportBasePath);
-                        }
-                    }
-                }
-            }
-
-            return patch;
-        }
-
-        /// <summary>
-        /// Unbind an MSI transform file.
-        /// </summary>
-        /// <param name="transformFile">The transform file.</param>
-        /// <param name="exportBasePath">The path where files should be exported.</param>
-        /// <returns>The unbound transform.</returns>
-        private Output UnbindTransform(string transformFile, string exportBasePath)
-        {
-            Output transform = new Output(new SourceLineNumber(transformFile));
-            transform.Type = OutputType.Transform;
-
-            // get the summary information table
-            using (SummaryInformation summaryInformation = new SummaryInformation(transformFile))
-            {
-                Table table = transform.EnsureTable(this.tableDefinitions["_SummaryInformation"]);
-
-                for (int i = 1; 19 >= i; i++)
-                {
-                    string value = summaryInformation.GetProperty(i);
-
-                    if (0 < value.Length)
-                    {
-                        Row row = table.CreateRow(transform.SourceLineNumbers);
-                        row[0] = i;
-                        row[1] = value;
-                    }
-                }
-            }
-
-            // create a schema msi which hopefully matches the table schemas in the transform
-            Output schemaOutput = new Output(null);
-            string msiDatabaseFile = Path.Combine(this.TempFilesLocation, "schema.msi");
-            foreach (TableDefinition tableDefinition in this.tableDefinitions)
-            {
-                // skip unreal tables and the Patch table
-                if (!tableDefinition.Unreal && "Patch" != tableDefinition.Name)
-                {
-                    schemaOutput.EnsureTable(tableDefinition);
-                }
-            }
-
-            Hashtable addedRows = new Hashtable();
-            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))
-            {
-                // apply the transform with the ViewTransform option to collect all the modifications
-                msiDatabase.ApplyTransform(transformFile, TransformErrorConditions.All | TransformErrorConditions.ViewTransform);
-
-                // unbind the database
-                Output transformViewOutput = this.UnbindDatabase(msiDatabaseFile, msiDatabase, OutputType.Product, exportBasePath, true);
-
-                // 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)
-                {
-                    string tableName = (string)row[0];
-                    string columnName = (string)row[1];
-                    string primaryKeys = (string)row[2];
-
-                    if ("INSERT" == columnName)
-                    {
-                        string 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);
-
-                        modifiedRows[index] = row;
-                    }
-                }
-
-                // 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];
-
-                    string index = String.Concat(tableName, ':', primaryKeys);
-
-                    // ignore information for added rows
-                    if (!addedRows.Contains(index))
-                    {
-                        Table table = schemaOutput.Tables[tableName];
-                        this.CreateRow(table, primaryKeys, true);
-                    }
-                }
-            }
-
-            // Re-bind the schema output with the placeholder rows.
-            this.GenerateDatabase(schemaOutput, msiDatabaseFile);
-
-            // apply the transform to the database and retrieve the modifications
-            using (Database msiDatabase = new Database(msiDatabaseFile, OpenDatabase.Transact))
-            {
-                try
-                {
-                    // apply the transform
-                    msiDatabase.ApplyTransform(transformFile, TransformErrorConditions.All);
-
-                    // commit the database to guard against weird errors with streams
-                    msiDatabase.Commit();
-                }
-                catch (Win32Exception ex)
-                {
-                    if (0x65B == ex.NativeErrorCode)
-                    {
-                        // this commonly happens when the transform was built
-                        // against a database schema different from the internal
-                        // table definitions
-                        throw new WixException(WixErrors.TransformSchemaMismatch());
-                    }
-                }
-
-                // unbind the database
-                Output output = this.UnbindDatabase(msiDatabaseFile, msiDatabase, OutputType.Product, exportBasePath, true);
-
-                // index all the rows to easily find modified rows
-                Hashtable rows = new Hashtable();
-                foreach (Table table in output.Tables)
-                {
-                    foreach (Row 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)
-                {
-                    string tableName = (string)row[0];
-                    string columnName = (string)row[1];
-                    string primaryKeys = (string)row[2];
-
-                    Table table = transform.EnsureTable(this.tableDefinitions[tableName]);
-
-                    if ("CREATE" == columnName) // added table
-                    {
-                        table.Operation = TableOperation.Add;
-                    }
-                    else if ("DELETE" == columnName) // deleted row
-                    {
-                        Row deletedRow = this.CreateRow(table, primaryKeys, false);
-                        deletedRow.Operation = RowOperation.Delete;
-                    }
-                    else if ("DROP" == columnName) // dropped table
-                    {
-                        table.Operation = TableOperation.Drop;
-                    }
-                    else if ("INSERT" == columnName) // added row
-                    {
-                        string index = String.Concat(tableName, ':', primaryKeys);
-                        Row addedRow = (Row)rows[index];
-                        addedRow.Operation = RowOperation.Add;
-                        table.Rows.Add(addedRow);
-                    }
-                    else if (null != primaryKeys) // modified row
-                    {
-                        string 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))
-                        {
-                            Row modifiedRow = (Row)rows[index];
-
-                            // mark the field as modified
-                            int indexOfModifiedValue = -1;
-                            for (int i = 0; i < modifiedRow.TableDefinition.Columns.Count; ++i)
-                            {
-                                if (columnName.Equals(modifiedRow.TableDefinition.Columns[i].Name, StringComparison.Ordinal))
-                                {
-                                    indexOfModifiedValue = i;
-                                    break;
-                                }
-                            }
-                            modifiedRow.Fields[indexOfModifiedValue].Modified = true;
-
-                            // move the modified row into the transform the first time its encountered
-                            if (RowOperation.None == modifiedRow.Operation)
-                            {
-                                modifiedRow.Operation = RowOperation.Modify;
-                                table.Rows.Add(modifiedRow);
-                            }
-                        }
-                    }
-                    else // added column
-                    {
-                        ColumnDefinition column = table.Definition.Columns.Single(c => c.Name.Equals(columnName, StringComparison.Ordinal));
-                        column.Added = true;
-                    }
-                }
-            }
-
-            return transform;
-        }
-
-        private void GenerateDatabase(Output output, string databaseFile)
-        {
-            GenerateDatabaseCommand command = new GenerateDatabaseCommand();
-            command.Extensions = Enumerable.Empty<IBinderExtension>();
-            command.FileManagers = Enumerable.Empty<IBinderFileManager>();
-            command.Output = output;
-            command.OutputPath = databaseFile;
-            command.KeepAddedColumns = true;
-            command.UseSubDirectory = false;
-            command.SuppressAddingValidationRows = true;
-            command.TableDefinitions = this.tableDefinitions;
-            command.TempFilesLocation = this.TempFilesLocation;
-            command.Codepage = -1;
-            command.Execute();
-        }
-
-        /// <summary>
-        /// Unbind a bundle.
-        /// </summary>
-        /// <param name="bundleFile">The bundle file.</param>
-        /// <param name="exportBasePath">The path where files should be exported.</param>
-        /// <returns>The unbound bundle.</returns>
-        private Output UnbindBundle(string bundleFile, string exportBasePath)
-        {
-            string uxExtractPath = Path.Combine(exportBasePath, "UX");
-            string acExtractPath = Path.Combine(exportBasePath, "AttachedContainer");
-
-            using (BurnReader reader = BurnReader.Open(bundleFile))
-            {
-                reader.ExtractUXContainer(uxExtractPath, this.TempFilesLocation);
-                reader.ExtractAttachedContainer(acExtractPath, this.TempFilesLocation);
-            }
+            // TODO: Display message that could not find a unbinder for output type?
 
             return null;
         }
-
-        /// <summary>
-        /// Create a deleted or modified row.
-        /// </summary>
-        /// <param name="table">The table containing the row.</param>
-        /// <param name="primaryKeys">The primary keys of the row.</param>
-        /// <param name="setRequiredFields">Option to set all required fields with placeholder values.</param>
-        /// <returns>The new row.</returns>
-        private Row CreateRow(Table table, string primaryKeys, bool setRequiredFields)
-        {
-            Row row = table.CreateRow(null);
-
-            string[] primaryKeyParts = primaryKeys.Split('\t');
-            int primaryKeyPartIndex = 0;
-
-            for (int i = 0; i < table.Definition.Columns.Count; i++)
-            {
-                ColumnDefinition columnDefinition = table.Definition.Columns[i];
-
-                if (columnDefinition.PrimaryKey)
-                {
-                    if (ColumnType.Number == columnDefinition.Type && !columnDefinition.IsLocalizable)
-                    {
-                        row[i] = Convert.ToInt32(primaryKeyParts[primaryKeyPartIndex++], CultureInfo.InvariantCulture);
-                    }
-                    else
-                    {
-                        row[i] = primaryKeyParts[primaryKeyPartIndex++];
-                    }
-                }
-                else if (setRequiredFields)
-                {
-                    if (ColumnType.Number == columnDefinition.Type && !columnDefinition.IsLocalizable)
-                    {
-                        row[i] = 1;
-                    }
-                    else if (ColumnType.Object == columnDefinition.Type)
-                    {
-                        if (null == this.emptyFile)
-                        {
-                            this.emptyFile = Path.GetTempFileName() + ".empty";
-                            using (FileStream fileStream = File.Create(this.emptyFile))
-                            {
-                            }
-                        }
-
-                        row[i] = this.emptyFile;
-                    }
-                    else
-                    {
-                        row[i] = "1";
-                    }
-                }
-            }
-
-            return row;
-        }
-
-        /// <summary>
-        /// Extract the cabinets from a database.
-        /// </summary>
-        /// <param name="output">The output to use when finding cabinets.</param>
-        /// <param name="database">The database containing the cabinets.</param>
-        /// <param name="databaseFile">The location of the database file.</param>
-        /// <param name="exportBasePath">The path where the files should be exported.</param>
-        private void ExtractCabinets(Output output, Database database, string databaseFile, string exportBasePath)
-        {
-            string databaseBasePath = Path.GetDirectoryName(databaseFile);
-            StringCollection cabinetFiles = new StringCollection();
-            SortedList embeddedCabinets = new SortedList();
-
-            // index all of the cabinet files
-            if (OutputType.Module == output.Type)
-            {
-                embeddedCabinets.Add(0, "MergeModule.CABinet");
-            }
-            else if (null != output.Tables["Media"])
-            {
-                foreach (MediaRow mediaRow in output.Tables["Media"].Rows)
-                {
-                    if (null != mediaRow.Cabinet)
-                    {
-                        if (OutputType.Product == output.Type ||
-                            (OutputType.Transform == output.Type && RowOperation.Add == mediaRow.Operation))
-                        {
-                            if (mediaRow.Cabinet.StartsWith("#", StringComparison.Ordinal))
-                            {
-                                embeddedCabinets.Add(mediaRow.DiskId, mediaRow.Cabinet.Substring(1));
-                            }
-                            else
-                            {
-                                cabinetFiles.Add(Path.Combine(databaseBasePath, mediaRow.Cabinet));
-                            }
-                        }
-                    }
-                }
-            }
-
-            // extract the embedded cabinet files from the database
-            if (0 < embeddedCabinets.Count)
-            {
-                using (View streamsView = database.OpenView("SELECT `Data` FROM `_Streams` WHERE `Name` = ?"))
-                {
-                    foreach (int diskId in embeddedCabinets.Keys)
-                    {
-                        using (Record record = new Record(1))
-                        {
-                            record.SetString(1, (string)embeddedCabinets[diskId]);
-                            streamsView.Execute(record);
-                        }
-
-                        using (Record record = streamsView.Fetch())
-                        {
-                            if (null != record)
-                            {
-                                // since the cabinets are stored in case-sensitive streams inside the msi, but the file system is not case-sensitive,
-                                // embedded cabinets must be extracted to a canonical file name (like their diskid) to ensure extraction will always work
-                                string cabinetFile = Path.Combine(this.TempFilesLocation, String.Concat("Media", Path.DirectorySeparatorChar, diskId.ToString(CultureInfo.InvariantCulture), ".cab"));
-
-                                // ensure the parent directory exists
-                                System.IO.Directory.CreateDirectory(Path.GetDirectoryName(cabinetFile));
-
-                                using (FileStream fs = System.IO.File.Create(cabinetFile))
-                                {
-                                    int bytesRead;
-                                    byte[] buffer = new byte[512];
-
-                                    while (0 != (bytesRead = record.GetStream(1, buffer, buffer.Length)))
-                                    {
-                                        fs.Write(buffer, 0, bytesRead);
-                                    }
-                                }
-
-                                cabinetFiles.Add(cabinetFile);
-                            }
-                            else
-                            {
-                                // TODO: warning about missing embedded cabinet
-                            }
-                        }
-                    }
-                }
-            }
-
-            // extract the cabinet files
-            if (0 < cabinetFiles.Count)
-            {
-                string fileDirectory = Path.Combine(exportBasePath, "File");
-
-                // delete the directory and its files to prevent cab extraction due to an existing file
-                if (Directory.Exists(fileDirectory))
-                {
-                    Directory.Delete(fileDirectory, true);
-                }
-
-                // ensure the directory exists or extraction will fail
-                Directory.CreateDirectory(fileDirectory);
-
-                foreach (string cabinetFile in cabinetFiles)
-                {
-                    using (WixExtractCab extractCab = new WixExtractCab())
-                    {
-                        try
-                        {
-                            extractCab.Extract(cabinetFile, fileDirectory);
-                        }
-                        catch (FileNotFoundException)
-                        {
-                            throw new WixException(WixErrors.FileNotFound(new SourceLineNumber(databaseFile), cabinetFile));
-                        }
-                    }
-                }
-            }
-        }
     }
 }
diff --git a/src/WixToolset.Core/Uuid.cs b/src/WixToolset.Core/Uuid.cs
index 2e599793..d512d92f 100644
--- a/src/WixToolset.Core/Uuid.cs
+++ b/src/WixToolset.Core/Uuid.cs
@@ -10,7 +10,7 @@ namespace WixToolset
     /// <summary>
     /// Implementation of RFC 4122 - A Universally Unique Identifier (UUID) URN Namespace.
     /// </summary>
-    internal sealed class Uuid
+    public sealed class Uuid
     {
         /// <summary>
         /// Protect the constructor.
diff --git a/src/WixToolset.Core/WixStrings.Designer.cs b/src/WixToolset.Core/WixStrings.Designer.cs
index 4ba9381a..75e2b908 100644
--- a/src/WixToolset.Core/WixStrings.Designer.cs
+++ b/src/WixToolset.Core/WixStrings.Designer.cs
@@ -14,7 +14,7 @@ namespace WixToolset {
     [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
     [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
     [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
-    internal class WixStrings {
+    public class WixStrings {
         
         private static global::System.Resources.ResourceManager resourceMan;
         
@@ -127,7 +127,7 @@ namespace WixToolset {
         /// <summary>
         ///   Looks up a localized string similar to Could not determine ProductCode from transform summary information.
         /// </summary>
-        internal static string EXP_CouldnotDetermineProductCodeFromTransformSummaryInfo {
+        public static string EXP_CouldnotDetermineProductCodeFromTransformSummaryInfo {
             get {
                 return ResourceManager.GetString("EXP_CouldnotDetermineProductCodeFromTransformSummaryInfo", resourceCulture);
             }
@@ -226,7 +226,7 @@ namespace WixToolset {
         /// <summary>
         ///   Looks up a localized string similar to Transform authored into multiple Media &apos;{0}&apos; and &apos;{1}&apos;..
         /// </summary>
-        internal static string EXP_TransformAuthoredIntoMultipleMedia {
+        public static string EXP_TransformAuthoredIntoMultipleMedia {
             get {
                 return ResourceManager.GetString("EXP_TransformAuthoredIntoMultipleMedia", resourceCulture);
             }
@@ -253,7 +253,7 @@ namespace WixToolset {
         /// <summary>
         ///   Looks up a localized string similar to Encountered an unexpected error while merging &apos;{0}&apos;. More information about the merge and the failure can be found in the merge log: &apos;{1}&apos;.
         /// </summary>
-        internal static string EXP_UnexpectedMergerErrorInSourceFile {
+        public static string EXP_UnexpectedMergerErrorInSourceFile {
             get {
                 return ResourceManager.GetString("EXP_UnexpectedMergerErrorInSourceFile", resourceCulture);
             }
@@ -262,7 +262,7 @@ namespace WixToolset {
         /// <summary>
         ///   Looks up a localized string similar to Encountered an unexpected merge error of type &apos;{0}&apos; for which there is currently no error message to display.  More information about the merge and the failure can be found in the merge log: &apos;{1}&apos;.
         /// </summary>
-        internal static string EXP_UnexpectedMergerErrorWithType {
+        public static string EXP_UnexpectedMergerErrorWithType {
             get {
                 return ResourceManager.GetString("EXP_UnexpectedMergerErrorWithType", resourceCulture);
             }
diff --git a/src/WixToolset.Core/WixVariableResolver.cs b/src/WixToolset.Core/WixVariableResolver.cs
index d437423c..357ff700 100644
--- a/src/WixToolset.Core/WixVariableResolver.cs
+++ b/src/WixToolset.Core/WixVariableResolver.cs
@@ -1,6 +1,6 @@
 // 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
+namespace WixToolset.Core
 {
     using System;
     using System.Collections.Generic;
@@ -10,11 +10,12 @@ namespace WixToolset
     using System.Text.RegularExpressions;
     using WixToolset.Data;
     using WixToolset.Data.Rows;
+    using WixToolset.Extensibility;
 
     /// <summary>
     /// WiX variable resolver.
     /// </summary>
-    public sealed class WixVariableResolver
+    internal sealed class WixVariableResolver : IBindVariableResolver
     {
         private Dictionary<string, string> wixVariables;
 
@@ -31,7 +32,7 @@ namespace WixToolset
         /// Gets or sets the localizer.
         /// </summary>
         /// <value>The localizer.</value>
-        public Localizer Localizer { get; private set; }
+        private Localizer Localizer { get; }
 
         /// <summary>
         /// Gets the count of variables added to the resolver.
@@ -83,10 +84,7 @@ namespace WixToolset
         /// <returns>The resolved value.</returns>
         public string ResolveVariables(SourceLineNumber sourceLineNumbers, string value, bool localizationOnly)
         {
-            bool isDefault = false;
-            bool delayedResolve = false;
-
-            return this.ResolveVariables(sourceLineNumbers, value, localizationOnly, ref isDefault, ref delayedResolve);
+            return this.ResolveVariables(sourceLineNumbers, value, localizationOnly, out var defaultIgnored, out var delayedIgnored);
         }
 
         /// <summary>
@@ -97,11 +95,9 @@ namespace WixToolset
         /// <param name="localizationOnly">true to only resolve localization variables; false otherwise.</param>
         /// <param name="isDefault">true if the resolved value was the default.</param>
         /// <returns>The resolved value.</returns>
-        public string ResolveVariables(SourceLineNumber sourceLineNumbers, string value, bool localizationOnly, ref bool isDefault)
+        public string ResolveVariables(SourceLineNumber sourceLineNumbers, string value, bool localizationOnly, out bool isDefault)
         {
-            bool delayedResolve = false;
-
-            return this.ResolveVariables(sourceLineNumbers, value, localizationOnly, ref isDefault, ref delayedResolve);
+            return this.ResolveVariables(sourceLineNumbers, value, localizationOnly, out isDefault, out var ignored);
         }
 
         /// <summary>
@@ -114,9 +110,9 @@ namespace WixToolset
         /// <param name="isDefault">true if the resolved value was the default.</param>
         /// <param name="delayedResolve">true if the value has variables that cannot yet be resolved.</param>
         /// <returns>The resolved value.</returns>
-        public string ResolveVariables(SourceLineNumber sourceLineNumbers, string value, bool localizationOnly, ref bool isDefault, ref bool delayedResolve)
+        public string ResolveVariables(SourceLineNumber sourceLineNumbers, string value, bool localizationOnly, out bool isDefault, out bool delayedResolve)
         {
-            return this.ResolveVariables(sourceLineNumbers, value, localizationOnly, true, ref isDefault, ref delayedResolve);
+            return this.ResolveVariables(sourceLineNumbers, value, localizationOnly, true, out isDefault, out delayedResolve);
         }
 
         /// <summary>
@@ -129,7 +125,7 @@ namespace WixToolset
         /// <param name="isDefault">true if the resolved value was the default.</param>
         /// <param name="delayedResolve">true if the value has variables that cannot yet be resolved.</param>
         /// <returns>The resolved value.</returns>
-        public string ResolveVariables(SourceLineNumber sourceLineNumbers, string value, bool localizationOnly, bool errorOnUnknown, ref bool isDefault, ref bool delayedResolve)
+        public string ResolveVariables(SourceLineNumber sourceLineNumbers, string value, bool localizationOnly, bool errorOnUnknown, out bool isDefault, out bool delayedResolve)
         {
             MatchCollection matches = Common.WixVariableRegex.Matches(value);
 
@@ -190,10 +186,7 @@ namespace WixToolset
                                 Messaging.Instance.OnMessage(WixWarnings.DeprecatedLocalizationVariablePrefix(sourceLineNumbers, variableId));
                             }
 
-                            if (null != this.Localizer)
-                            {
-                                resolvedValue = this.Localizer.GetLocalizedValue(variableId);
-                            }
+                            resolvedValue = this.Localizer?.GetLocalizedValue(variableId);
                         }
                         else if (!localizationOnly && "wix" == variableNamespace)
                         {
@@ -223,6 +216,7 @@ namespace WixToolset
                         }
                         else
                         {
+
                             // insert the resolved value if it was found or display an error
                             if (null != resolvedValue)
                             {
@@ -248,6 +242,19 @@ namespace WixToolset
         }
 
         /// <summary>
+        /// Try to find localization information for dialog and (optional) control.
+        /// </summary>
+        /// <param name="dialog">Dialog identifier.</param>
+        /// <param name="control">Optional control identifier.</param>
+        /// <param name="localizedControl">Found localization information.</param>
+        /// <returns>True if localized control was found, otherwise false.</returns>
+        public bool TryGetLocalizedControl(string dialog, string control, out LocalizedControl localizedControl)
+        {
+            localizedControl = this.Localizer?.GetLocalizedControl(dialog, control);
+            return localizedControl != null;
+        }
+
+        /// <summary>
         /// Resolve the delay variables in a value.
         /// </summary>
         /// <param name="sourceLineNumbers">The source line information for the value.</param>
diff --git a/src/wix/wix.csproj b/src/wix/wix.csproj
index f183be39..828793ae 100644
--- a/src/wix/wix.csproj
+++ b/src/wix/wix.csproj
@@ -21,6 +21,8 @@
 
   <ItemGroup>
     <ProjectReference Include="..\WixToolset.Core\WixToolset.Core.csproj" />
+    <ProjectReference Include="..\WixToolset.Core.Burn\WixToolset.Core.Burn.csproj" />
+    <ProjectReference Include="..\WixToolset.Core.WindowsInstaller\WixToolset.Core.WindowsInstaller.csproj" />
 
     <ProjectReference Include="$(WixToolsetRootFolder)\Data\src\WixToolset.Data\WixToolset.Data.csproj" Condition=" '$(Configuration)' == 'Debug' And Exists('$(WixToolsetRootFolder)\Data\src\WixToolset.Data\WixToolset.Data.csproj') " />
     <PackageReference Include="WixToolset.Data" Version="4.0.*" Condition=" '$(Configuration)' == 'Release' Or !Exists('$(WixToolsetRootFolder)\Data\src\WixToolset.Data\WixToolset.Data.csproj') " />