Make "decompile" an MSI-only command instead of a backend requirement

As much as I'd like decompiling to be global functionality provided
by all backends there are only two output types that support
decompiling: MSI and MSM. In the future, perhaps we can invest in a
generic symbols to source code converter that would reduce the
redundant work backends need to do today. Until then, make
decompile an MSI specific command

28 files changed, 468 insertions, 445 deletions

diff --git a/src/api/wix/WixToolset.Extensibility/Data/IDecompileContext.cs b/src/api/wix/WixToolset.Extensibility/Data/IWindowsInstallerDecompileContext.cs
index fe7d0465..f744121a 100644
--- a/src/api/wix/WixToolset.Extensibility/Data/IDecompileContext.cs
+++ b/src/api/wix/WixToolset.Extensibility/Data/IWindowsInstallerDecompileContext.cs
@@ -5,21 +5,40 @@ namespace WixToolset.Extensibility.Data
     using System;
     using System.Collections.Generic;
     using WixToolset.Data;
-    using WixToolset.Extensibility.Services;
 
-#pragma warning disable 1591 // TODO: add documentation
-    public interface IDecompileContext
+    /// <summary>
+    /// The context used to decompile Windows Installer packages.
+    /// </summary>
+    public interface IWindowsInstallerDecompileContext
     {
+        /// <summary>
+        /// Gets or sets the service provider.
+        /// </summary>
         IServiceProvider ServiceProvider { get; }
 
+        /// <summary>
+        /// Gets or sets the path to the file to decompile.
+        /// </summary>
         string DecompilePath { get; set; }
 
+        /// <summary>
+        /// Gets or sets the type to decompile.
+        /// </summary>
         OutputType DecompileType { get; set; }
 
-        IReadOnlyCollection<IDecompilerExtension> Extensions { get; set; }
+        /// <summary>
+        /// Gets or sets the decompiler extensions.
+        /// </summary>
+        IReadOnlyCollection<IWindowsInstallerDecompilerExtension> Extensions { get; set; }
 
+        /// <summary>
+        /// Gets or sets the folder where content is extracted.
+        /// </summary>
         string ExtractFolder { get; set; }
 
+        /// <summary>
+        /// Gets or sets the folder where files are extracted.
+        /// </summary>
         string CabinetExtractFolder { get; set; }
 
         /// <summary>
@@ -28,10 +47,19 @@ namespace WixToolset.Extensibility.Data
         /// <remarks>Default value is "SourceDir" to enable use of BindPaths.</remarks>
         string BaseSourcePath { get; set; }
 
+        /// <summary>
+        /// Gets or sets the intermediate folder.
+        /// </summary>
         string IntermediateFolder { get; set; }
 
+        /// <summary>
+        /// Gets or sets whether the decompiler admin image.
+        /// </summary>
         bool IsAdminImage { get; set; }
 
+        /// <summary>
+        /// Gets or sets where to output the result.
+        /// </summary>
         string OutputPath { get; set; }
 
         /// <summary>
@@ -44,9 +72,17 @@ namespace WixToolset.Extensibility.Data
         /// </summary>
         bool SuppressDroppingEmptyTables { get; set; }
 
+        /// <summary>
+        /// Gets or sets whether to prevent extract cabinets.
+        /// </summary>
         bool SuppressExtractCabinets { get; set; }
 
         /// <summary>
+        /// Gets or sets whether to suppress relative action sequencing.
+        /// </summary>
+        bool SuppressRelativeActionSequencing { get; set; }
+
+        /// <summary>
         /// Gets or sets the option to suppress decompiling UI-related tables.
         /// </summary>
         bool SuppressUI { get; set; }
diff --git a/src/api/wix/WixToolset.Extensibility/Data/IDecompileResult.cs b/src/api/wix/WixToolset.Extensibility/Data/IWindowsInstallerDecompileResult.cs
index cffd0976..3b1dd815 100644
--- a/src/api/wix/WixToolset.Extensibility/Data/IDecompileResult.cs
+++ b/src/api/wix/WixToolset.Extensibility/Data/IWindowsInstallerDecompileResult.cs
@@ -7,7 +7,7 @@ namespace WixToolset.Extensibility.Data
     using WixToolset.Data;
 
 #pragma warning disable 1591 // TODO: add documentation
-    public interface IDecompileResult
+    public interface IWindowsInstallerDecompileResult
     {
         XDocument Document { get; set; }
 
diff --git a/src/api/wix/WixToolset.Extensibility/IBackend.cs b/src/api/wix/WixToolset.Extensibility/IBackend.cs
index cb151e05..720abe15 100644
--- a/src/api/wix/WixToolset.Extensibility/IBackend.cs
+++ b/src/api/wix/WixToolset.Extensibility/IBackend.cs
@@ -15,8 +15,5 @@ namespace WixToolset.Extensibility
         /// <param name="context">Bind context.</param>
         /// <returns>Result of the bind operation.</returns>
         IBindResult Bind(IBindContext context);
-
-#pragma warning disable 1591 // TODO: add documentation
-        IDecompileResult Decompile(IDecompileContext context);
     }
 }
diff --git a/src/api/wix/WixToolset.Extensibility/IBackendFactory.cs b/src/api/wix/WixToolset.Extensibility/IBackendFactory.cs
index 7f9ef62d..8e84f5b6 100644
--- a/src/api/wix/WixToolset.Extensibility/IBackendFactory.cs
+++ b/src/api/wix/WixToolset.Extensibility/IBackendFactory.cs
@@ -3,7 +3,7 @@
 namespace WixToolset.Extensibility
 {
     /// <summary>
-    /// Implemented by extensions to create backends.
+    /// Implemented by extensions that are backends.
     /// </summary>
     public interface IBackendFactory
     {
@@ -12,8 +12,8 @@ namespace WixToolset.Extensibility
         /// </summary>
         /// <param name="outputType">Type of output being created.</param>
         /// <param name="outputPath">Path to the output to create.</param>
-        /// <param name="backend">The backend for the output.</param>
+        /// <param name="binder">The backend for the output.</param>
         /// <returns>True if the backend was created, otherwise false.</returns>
-        bool TryCreateBackend(string outputType, string outputPath, out IBackend backend);
+        bool TryCreateBackend(string outputType, string outputPath, out IBackend binder);
     }
 }
diff --git a/src/api/wix/WixToolset.Extensibility/IDecompilerExtension.cs b/src/api/wix/WixToolset.Extensibility/IDecompilerExtension.cs
deleted file mode 100644
index 24ef3bff..00000000
--- a/src/api/wix/WixToolset.Extensibility/IDecompilerExtension.cs
+++ /dev/null
@@ -1,22 +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.Extensibility
-{
-    using WixToolset.Extensibility.Data;
-
-    /// <summary>
-    /// Base class for creating a decompiler extension.
-    /// </summary>
-    public interface IDecompilerExtension
-    {
-        /// <summary>
-        /// Called before decompiling occurs.
-        /// </summary>
-        void PreDecompile(IDecompileContext context);
-
-        /// <summary>
-        /// Called after all decompiling occurs.
-        /// </summary>
-        void PostDecompile(IDecompileResult result);
-    }
-}
diff --git a/src/api/wix/WixToolset.Extensibility/IWindowsInstallerBackendDecompilerExtension.cs b/src/api/wix/WixToolset.Extensibility/IWindowsInstallerDecompilerExtension.cs
index a56b63c3..add5f886 100644
--- a/src/api/wix/WixToolset.Extensibility/IWindowsInstallerBackendDecompilerExtension.cs
+++ b/src/api/wix/WixToolset.Extensibility/IWindowsInstallerDecompilerExtension.cs
@@ -9,18 +9,18 @@ namespace WixToolset.Extensibility
     /// <summary>
     /// Interface all binder extensions implement.
     /// </summary>
-    public interface IWindowsInstallerBackendDecompilerExtension
+    public interface IWindowsInstallerDecompilerExtension
     {
         /// <summary>
         /// Called before decompiling occurs.
         /// </summary>
-        void PreBackendDecompile(IDecompileContext context);
+        void PreDecompile(IWindowsInstallerDecompileContext context);
 
         // TODO: Redesign this interface to be useful.
 
         /// <summary>
         /// Called after all output changes occur and right before the output is bound into its final format.
         /// </summary>
-        void PostBackendDecompile(IDecompileResult result);
+        void PostDecompile(IWindowsInstallerDecompileResult result);
     }
 }
diff --git a/src/api/wix/WixToolset.Extensibility/Services/ICommandLineParser.cs b/src/api/wix/WixToolset.Extensibility/Services/ICommandLineParser.cs
index cd17f100..efd6600d 100644
--- a/src/api/wix/WixToolset.Extensibility/Services/ICommandLineParser.cs
+++ b/src/api/wix/WixToolset.Extensibility/Services/ICommandLineParser.cs
@@ -5,36 +5,111 @@ namespace WixToolset.Extensibility.Services
     using System.Collections.Generic;
     using WixToolset.Data;
 
-#pragma warning disable 1591 // TODO: add documentation
+    /// <summary>
+    /// Provides the command-line arguments.
+    /// </summary>
     public interface ICommandLineParser
     {
+        /// <summary>
+        /// Gets the argument that caused the error.
+        /// </summary>
         string ErrorArgument { get; }
 
         /// <summary>
         /// Validates that a valid switch (starts with "/" or "-"), and returns a bool indicating its validity
         /// </summary>
-        /// <param name="arg">The string check.</param>
+        /// <param name="argument">The string check.</param>
         /// <returns>True if a valid switch, otherwise false.</returns>
-        bool IsSwitch(string arg);
+        bool IsSwitch(string argument);
 
+        /// <summary>
+        /// Gets the current argument as a file or displays an error.
+        /// </summary>
+        /// <param name="argument">Current argument used in the error message if necessary.</param>
+        /// <param name="fileType">Type of file displayed in the error message if necessary.</param>
+        /// <returns>The fully expanded path if the argument is a file path, otherwise null.</returns>
         string GetArgumentAsFilePathOrError(string argument, string fileType);
 
-        void GetArgumentAsFilePathOrError(string argument, string fileType, IList<string> paths);
+        /// <summary>
+        /// Adds the current argument as a file to the list or displays an error.
+        /// </summary>
+        /// <param name="argument">Current argument used in the error message if necessary.</param>
+        /// <param name="fileType">Type of file displayed in the error message if necessary.</param>
+        /// <param name="paths">List to add the fully expanded path if the argument is a file path.</param>
+        /// <returns>True if the argument is a file path, otherwise false.</returns>
+        bool GetArgumentAsFilePathOrError(string argument, string fileType, IList<string> paths);
 
-        string GetNextArgumentOrError(string commandLineSwitch);
+        /// <summary>
+        /// Gets the next argument or displays error if no argument is available.
+        /// </summary>
+        /// <param name="argument">Current argument used in the error message if necessary.</param>
+        /// <returns>The next argument if present or null</returns>
+        string GetNextArgumentOrError(string argument);
 
-        bool GetNextArgumentOrError(string commandLineSwitch, IList<string> argument);
+        /// <summary>
+        /// Adds the next argument to a list or displays error if no argument is available.
+        /// </summary>
+        /// <param name="argument">Current argument used in the error message if necessary.</param>
+        /// <param name="arguments">List to add the argument to.</param>
+        /// <returns>True if an argument is available, otherwise false.</returns>
+        bool GetNextArgumentOrError(string argument, IList<string> arguments);
 
-        string GetNextArgumentAsDirectoryOrError(string commandLineSwitch);
+        /// <summary>
+        /// Gets the next argument as a directory or displays an error.
+        /// </summary>
+        /// <param name="argument">Current argument used in the error message if necessary.</param>
+        /// <returns>The fully expanded path if the argument is a directory, otherwise null.</returns>
+        string GetNextArgumentAsDirectoryOrError(string argument);
 
-        bool GetNextArgumentAsDirectoryOrError(string commandLineSwitch, IList<string> directories);
+        /// <summary>
+        /// Adds the next argument as a directory to the list or displays an error.
+        /// </summary>
+        /// <param name="argument">Current argument used in the error message if necessary.</param>
+        /// <param name="directories">List to add the fully expanded directory if the argument is a file path.</param>
+        /// <returns>True if the argument is a directory, otherwise false.</returns>
+        bool GetNextArgumentAsDirectoryOrError(string argument, IList<string> directories);
 
-        string GetNextArgumentAsFilePathOrError(string commandLineSwitch);
+        /// <summary>
+        /// Gets the next argument as a file or displays an error.
+        /// </summary>
+        /// <param name="argument">Current argument used in the error message if necessary.</param>
+        /// <returns>The fully expanded path if the argument is a file path, otherwise null.</returns>
+        string GetNextArgumentAsFilePathOrError(string argument);
 
-        bool GetNextArgumentAsFilePathOrError(string commandLineSwitch, string fileType, IList<string> paths);
+        /// <summary>
+        /// Adds the next argument as a file to the list or displays an error.
+        /// </summary>
+        /// <param name="argument">Current argument used in the error message if necessary.</param>
+        /// <param name="fileType">Type of file displayed in the error message if necessary.</param>
+        /// <param name="paths">List to add the fully expanded path if the argument is a file path.</param>
+        /// <returns>True if the argument is a file path, otherwise false.</returns>
+        bool GetNextArgumentAsFilePathOrError(string argument, string fileType, IList<string> paths);
 
+        /// <summary>
+        /// Reports a command line error for the provided argument.
+        /// </summary>
+        /// <param name="argument">Argument that caused the error.</param>
+        /// <param name="message">Message to report.</param>
         void ReportErrorArgument(string argument, Message message = null);
 
-        bool TryGetNextSwitchOrArgument(out string arg);
+        /// <summary>
+        /// Tries to get the next argument.
+        /// </summary>
+        /// <param name="argument">Next argument if available.</param>
+        /// <returns>True if argument is available, otherwise false.</returns>
+        bool TryGetNextSwitchOrArgument(out string argument);
+
+        /// <summary>
+        /// Looks ahead to the next argument without moving to the next argument.
+        /// </summary>
+        /// <returns>Next argument if available, otherwise null.</returns>
+        string PeekNextArgument();
+
+        /// <summary>
+        /// Tries to looks ahead to the next argument without moving to the next argument.
+        /// </summary>
+        /// <param name="argument">Argument found if present.</param>
+        /// <returns>True if argument is found, otherwise false.</returns>
+        bool TryPeekNextArgument(out string argument);
     }
 }
diff --git a/src/wix/WixToolset.Core.Burn/BundleBackend.cs b/src/wix/WixToolset.Core.Burn/BundleBackend.cs
index a2003989..cf1971f6 100644
--- a/src/wix/WixToolset.Core.Burn/BundleBackend.cs
+++ b/src/wix/WixToolset.Core.Burn/BundleBackend.cs
@@ -2,7 +2,6 @@
 
 namespace WixToolset.Core.Burn
 {
-    using System;
     using WixToolset.Extensibility;
     using WixToolset.Extensibility.Data;
     using WixToolset.Extensibility.Services;
@@ -35,10 +34,5 @@ namespace WixToolset.Core.Burn
 
             return result;
         }
-
-        public IDecompileResult Decompile(IDecompileContext context)
-        {
-            throw new NotImplementedException();
-        }
     }
 }
diff --git a/src/wix/WixToolset.Core.WindowsInstaller/CommandLine/DecompilerSubcommand.cs b/src/wix/WixToolset.Core.WindowsInstaller/CommandLine/DecompilerSubcommand.cs
new file mode 100644
index 00000000..19d1c738
--- /dev/null
+++ b/src/wix/WixToolset.Core.WindowsInstaller/CommandLine/DecompilerSubcommand.cs
@@ -0,0 +1,185 @@
+// 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.CommandLine
+{
+    using System;
+    using System.IO;
+    using System.Threading;
+    using System.Threading.Tasks;
+    using System.Xml.Linq;
+    using WixToolset.Data;
+    using WixToolset.Extensibility;
+    using WixToolset.Extensibility.Data;
+    using WixToolset.Extensibility.Services;
+
+    internal class DecompilerSubcommand : WindowsInstallerSubcommandBase
+    {
+        public DecompilerSubcommand(IServiceProvider serviceProvider)
+        {
+            this.ServiceProvider = serviceProvider;
+            this.Messaging = serviceProvider.GetService<IMessaging>();
+        }
+
+        private IServiceProvider ServiceProvider { get; }
+
+        private IMessaging Messaging { get; }
+
+        private string InputPath { get; set; }
+
+        private string DecompileType { get; set; }
+
+        private string IntermediateFolder { get; set; }
+
+        private string OutputPath { get; set; }
+
+        private string ExportBasePath { get; set; }
+
+        private bool SuppressCustomTables { get; set; }
+
+        private bool SuppressDroppingEmptyTables { get; set; }
+
+        private bool SuppressRelativeActionSequencing { get; set; }
+
+        private bool SuppressUI { get; set; }
+
+        public override Task<int> ExecuteAsync(CancellationToken cancellationToken)
+        {
+            if (String.IsNullOrEmpty(this.InputPath))
+            {
+                Console.Error.WriteLine("Input MSI or MSM database is required");
+                return Task.FromResult(-1);
+            }
+
+            if (!this.TryCalculateDecompileType(out var decompileType))
+            {
+                Console.Error.WriteLine("Unknown output type '{0}' from input: {1}", decompileType, this.InputPath);
+                return Task.FromResult(-1);
+            }
+
+            if (String.IsNullOrEmpty(this.IntermediateFolder))
+            {
+                this.IntermediateFolder = Path.GetTempPath();
+            }
+
+            if (String.IsNullOrEmpty(this.OutputPath))
+            {
+                this.OutputPath = Path.ChangeExtension(this.InputPath, ".wxs");
+            }
+
+            var context = this.ServiceProvider.GetService<IWindowsInstallerDecompileContext>();
+            context.Extensions = this.ServiceProvider.GetService<IExtensionManager>().GetServices<IWindowsInstallerDecompilerExtension>();
+            context.DecompilePath = this.InputPath;
+            context.DecompileType = decompileType;
+            context.IntermediateFolder = this.IntermediateFolder;
+            context.OutputPath = this.OutputPath;
+
+            context.ExtractFolder = this.ExportBasePath ?? this.IntermediateFolder;
+            context.SuppressCustomTables = this.SuppressCustomTables;
+            context.SuppressDroppingEmptyTables = this.SuppressDroppingEmptyTables;
+            context.SuppressRelativeActionSequencing = this.SuppressRelativeActionSequencing;
+            context.SuppressUI = this.SuppressUI;
+
+            try
+            {
+                var decompiler = this.ServiceProvider.GetService<IWindowsInstallerDecompiler>();
+                var result = decompiler.Decompile(context);
+
+                if (!this.Messaging.EncounteredError)
+                {
+                    Directory.CreateDirectory(Path.GetDirectoryName(Path.GetFullPath(context.OutputPath)));
+                    result.Document.Save(context.OutputPath, SaveOptions.OmitDuplicateNamespaces);
+                }
+            }
+            catch (WixException e)
+            {
+                this.Messaging.Write(e.Error);
+            }
+
+            return Task.FromResult(this.Messaging.LastErrorNumber);
+        }
+
+        public override bool TryParseArgument(ICommandLineParser parser, string argument)
+        {
+            if (parser.IsSwitch(argument))
+            {
+                var parameter = argument.Substring(1);
+                switch (parameter.ToLowerInvariant())
+                {
+                    case "intermediatefolder":
+                        this.IntermediateFolder = parser.GetNextArgumentAsDirectoryOrError(argument);
+                        return true;
+
+                    case "o":
+                    case "out":
+                        this.OutputPath = parser.GetNextArgumentAsFilePathOrError(argument);
+                        return true;
+
+                    case "sct":
+                        this.SuppressCustomTables = true;
+                        return true;
+
+                    case "sdet":
+                        this.SuppressDroppingEmptyTables = true;
+                        return true;
+
+                    case "sras":
+                        this.SuppressRelativeActionSequencing = true;
+                        return true;
+
+                    case "sui":
+                        this.SuppressUI = true;
+                        return true;
+
+                    case "type":
+                        this.DecompileType = parser.GetNextArgumentOrError(argument);
+                        return true;
+
+                    case "x":
+                        // Peek ahead to get the actual value provided on the command-line so the authoring
+                        // matches what they typed on the command-line.
+                        var originalExportBasePath = parser.PeekNextArgument();
+                        parser.GetNextArgumentAsDirectoryOrError(argument); // ensure we actually got a directory.
+
+                        this.ExportBasePath = originalExportBasePath;
+                        return true;
+                }
+            }
+            else if (String.IsNullOrEmpty(this.InputPath))
+            {
+                this.InputPath = argument;
+                return true;
+            }
+
+            return false;
+        }
+
+        private bool TryCalculateDecompileType(out OutputType decompileType)
+        {
+            decompileType = OutputType.Unknown;
+
+            if (String.IsNullOrEmpty(this.DecompileType))
+            {
+                this.DecompileType = Path.GetExtension(this.InputPath);
+            }
+
+            switch (this.DecompileType.ToLowerInvariant())
+            {
+                case "product":
+                case "package":
+                case "msi":
+                case ".msi":
+                    decompileType = OutputType.Product;
+                    break;
+
+                case "mergemodule":
+                case "module":
+                case "msm":
+                case ".msm":
+                    decompileType = OutputType.Module;
+                    break;
+            }
+
+            return decompileType != OutputType.Unknown;
+        }
+    }
+}
diff --git a/src/wix/WixToolset.Core.WindowsInstaller/CommandLine/WindowsInstallerCommand.cs b/src/wix/WixToolset.Core.WindowsInstaller/CommandLine/WindowsInstallerCommand.cs
index ed0c0658..f11020c8 100644
--- a/src/wix/WixToolset.Core.WindowsInstaller/CommandLine/WindowsInstallerCommand.cs
+++ b/src/wix/WixToolset.Core.WindowsInstaller/CommandLine/WindowsInstallerCommand.cs
@@ -45,6 +45,10 @@ namespace WixToolset.Core.WindowsInstaller.CommandLine
             {
                 switch (argument.ToLowerInvariant())
                 {
+                    case "decompile":
+                        this.Subcommand = new DecompilerSubcommand(this.ServiceProvider);
+                        return true;
+
                     case "inscribe":
                         this.Subcommand = new InscribeSubcommand(this.ServiceProvider);
                         return true;
diff --git a/src/wix/WixToolset.Core.WindowsInstaller/Decompile/DecompileMsiOrMsmCommand.cs b/src/wix/WixToolset.Core.WindowsInstaller/Decompile/DecompileMsiOrMsmCommand.cs
index aeda4443..5001828d 100644
--- a/src/wix/WixToolset.Core.WindowsInstaller/Decompile/DecompileMsiOrMsmCommand.cs
+++ b/src/wix/WixToolset.Core.WindowsInstaller/Decompile/DecompileMsiOrMsmCommand.cs
@@ -1,4 +1,4 @@
-// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+                        // Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
 
 namespace WixToolset.Core.WindowsInstaller.Decompile
 {
@@ -11,28 +11,24 @@ namespace WixToolset.Core.WindowsInstaller.Decompile
     using WixToolset.Core.WindowsInstaller.Unbind;
     using WixToolset.Data;
     using WixToolset.Data.WindowsInstaller;
-    using WixToolset.Extensibility;
     using WixToolset.Extensibility.Data;
     using WixToolset.Extensibility.Services;
 
     internal class DecompileMsiOrMsmCommand
     {
-        public DecompileMsiOrMsmCommand(IDecompileContext context, IEnumerable<IWindowsInstallerBackendDecompilerExtension> backendExtensions)
+        public DecompileMsiOrMsmCommand(IWindowsInstallerDecompileContext context)
         {
             this.Context = context;
-            this.Extensions = backendExtensions;
             this.Messaging = context.ServiceProvider.GetService<IMessaging>();
         }
 
-        private IDecompileContext Context { get; }
-
-        private IEnumerable<IWindowsInstallerBackendDecompilerExtension> Extensions { get; }
+        private IWindowsInstallerDecompileContext Context { get; }
 
         private IMessaging Messaging { get; }
 
-        public IDecompileResult Execute()
+        public IWindowsInstallerDecompileResult Execute()
         {
-            var result = this.Context.ServiceProvider.GetService<IDecompileResult>();
+            var result = this.Context.ServiceProvider.GetService<IWindowsInstallerDecompileResult>();
 
             try
             {
@@ -50,7 +46,7 @@ namespace WixToolset.Core.WindowsInstaller.Decompile
                     var output = unbindCommand.Execute();
                     var extractedFilePaths = new List<string>(unbindCommand.ExportedFiles);
 
-                    var decompiler = new Decompiler(this.Messaging, backendHelper, this.Extensions, this.Context.BaseSourcePath, this.Context.SuppressCustomTables, this.Context.SuppressDroppingEmptyTables, this.Context.SuppressUI, this.Context.TreatProductAsModule);
+                    var decompiler = new Decompiler(this.Messaging, backendHelper, this.Context.Extensions, this.Context.BaseSourcePath, this.Context.SuppressCustomTables, this.Context.SuppressDroppingEmptyTables, this.Context.SuppressRelativeActionSequencing, this.Context.SuppressUI, this.Context.TreatProductAsModule);
                     result.Document = decompiler.Decompile(output);
 
                     result.Platform = GetPlatformFromOutput(output);
@@ -90,7 +86,6 @@ namespace WixToolset.Core.WindowsInstaller.Decompile
             var template = output.Tables["_SummaryInformation"]?.Rows.SingleOrDefault(row => row.FieldAsInteger(0) == 7)?.FieldAsString(1);
 
             return Decompiler.GetPlatformFromTemplateSummaryInformation(template?.Split(';'));
-
         }
     }
 }
diff --git a/src/wix/WixToolset.Core.WindowsInstaller/Decompile/Decompiler.cs b/src/wix/WixToolset.Core.WindowsInstaller/Decompile/Decompiler.cs
index 9c338293..4ccfaaa5 100644
--- a/src/wix/WixToolset.Core.WindowsInstaller/Decompile/Decompiler.cs
+++ b/src/wix/WixToolset.Core.WindowsInstaller/Decompile/Decompiler.cs
@@ -43,7 +43,7 @@ namespace WixToolset.Core.WindowsInstaller.Decompile
         /// <summary>
         /// Creates a new decompiler object with a default set of table definitions.
         /// </summary>
-        public Decompiler(IMessaging messaging, IBackendHelper backendHelper, IEnumerable<IWindowsInstallerBackendDecompilerExtension> extensions, string baseSourcePath, bool suppressCustomTables, bool suppressDroppingEmptyTables, bool suppressUI, bool treatProductAsModule)
+        public Decompiler(IMessaging messaging, IBackendHelper backendHelper, IEnumerable<IWindowsInstallerDecompilerExtension> extensions, string baseSourcePath, bool suppressCustomTables, bool suppressDroppingEmptyTables, bool suppressRelativeActionSequencing, bool suppressUI, bool treatProductAsModule)
         {
             this.Messaging = messaging;
             this.BackendHelper = backendHelper;
@@ -51,10 +51,11 @@ namespace WixToolset.Core.WindowsInstaller.Decompile
             this.BaseSourcePath = baseSourcePath ?? "SourceDir";
             this.SuppressCustomTables = suppressCustomTables;
             this.SuppressDroppingEmptyTables = suppressDroppingEmptyTables;
+            this.SuppressRelativeActionSequencing = suppressRelativeActionSequencing;
             this.SuppressUI = suppressUI;
             this.TreatProductAsModule = treatProductAsModule;
 
-            this.ExtensionsByTableName = new Dictionary<string, IWindowsInstallerBackendDecompilerExtension>();
+            this.ExtensionsByTableName = new Dictionary<string, IWindowsInstallerDecompilerExtension>();
             this.StandardActions = WindowsInstallerStandard.StandardActions().ToDictionary(a => a.Id.Id);
 
             this.TableDefinitions = new TableDefinitionCollection();
@@ -64,9 +65,9 @@ namespace WixToolset.Core.WindowsInstaller.Decompile
 
         private IBackendHelper BackendHelper { get; }
 
-        private IEnumerable<IWindowsInstallerBackendDecompilerExtension> Extensions { get; }
+        private IEnumerable<IWindowsInstallerDecompilerExtension> Extensions { get; }
 
-        private Dictionary<string, IWindowsInstallerBackendDecompilerExtension> ExtensionsByTableName { get; }
+        private Dictionary<string, IWindowsInstallerDecompilerExtension> ExtensionsByTableName { get; }
 
         private string BaseSourcePath { get; }
 
@@ -238,7 +239,10 @@ namespace WixToolset.Core.WindowsInstaller.Decompile
         /// </summary>
         /// <param name="row">The row corresponding to the element.</param>
         /// <returns>The indexed element.</returns>
-        private XElement GetIndexedElement(WixToolset.Data.WindowsInstaller.Row row) => this.GetIndexedElement(row.TableDefinition.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter));
+        private XElement GetIndexedElement(Row row)
+        {
+            return this.GetIndexedElement(row.TableDefinition.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter));
+        }
 
         /// <summary>
         /// Gets the element corresponding to the primary key of the given table.
@@ -246,7 +250,10 @@ namespace WixToolset.Core.WindowsInstaller.Decompile
         /// <param name="table">The table corresponding to the element.</param>
         /// <param name="primaryKey">The primary key corresponding to the element.</param>
         /// <returns>The indexed element.</returns>
-        private XElement GetIndexedElement(string table, params string[] primaryKey) => this.IndexedElements[String.Concat(table, ':', String.Join(DecompilerConstants.PrimaryKeyDelimiterString, primaryKey))];
+        private XElement GetIndexedElement(string table, params string[] primaryKey)
+        {
+            return this.TryGetIndexedElement(table, out var element, primaryKey) ? element : null;
+        }
 
         /// <summary>
         /// Tries to get the element corresponding to the primary key of the given table.
@@ -254,7 +261,10 @@ namespace WixToolset.Core.WindowsInstaller.Decompile
         /// <param name="row">The table corresponding to the element.</param>
         /// <param name="xElement">The indexed element.</param>
         /// <returns>Whether the element was found.</returns>
-        private bool TryGetIndexedElement(WixToolset.Data.WindowsInstaller.Row row, out XElement xElement) => this.TryGetIndexedElement(row.TableDefinition.Name, out xElement, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter));
+        private bool TryGetIndexedElement(Row row, out XElement xElement)
+        {
+            return this.TryGetIndexedElement(row.TableDefinition.Name, out xElement, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter));
+        }
 
         /// <summary>
         /// Tries to get the element corresponding to the primary key of the given table.
@@ -263,14 +273,17 @@ namespace WixToolset.Core.WindowsInstaller.Decompile
         /// <param name="xElement">The indexed element.</param>
         /// <param name="primaryKey">The primary key corresponding to the element.</param>
         /// <returns>Whether the element was found.</returns>
-        private bool TryGetIndexedElement(string table, out XElement xElement, params string[] primaryKey) => this.IndexedElements.TryGetValue(String.Concat(table, ':', String.Join(DecompilerConstants.PrimaryKeyDelimiterString, primaryKey)), out xElement);
+        private bool TryGetIndexedElement(string table, out XElement xElement, params string[] primaryKey)
+        {
+            return this.IndexedElements.TryGetValue(String.Concat(table, ':', String.Join(DecompilerConstants.PrimaryKeyDelimiterString, primaryKey)), out xElement);
+        }
 
         /// <summary>
         /// Index an element by its corresponding row.
         /// </summary>
         /// <param name="row">The row corresponding to the element.</param>
         /// <param name="element">The element to index.</param>
-        private void IndexElement(WixToolset.Data.WindowsInstaller.Row row, XElement element)
+        private void IndexElement(Row row, XElement element)
         {
             this.IndexedElements.Add(String.Concat(row.TableDefinition.Name, ':', row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter)), element);
         }
@@ -293,9 +306,15 @@ namespace WixToolset.Core.WindowsInstaller.Decompile
                 .ToDictionary(lookup => lookup.Key, lookup => lookup.ToList());
         }
 
-        private Dictionary<string, List<XElement>> IndexTableOneToMany(TableIndexedCollection tables, string tableName, int column = 0) => this.IndexTableOneToMany(tables[tableName]?.Rows ?? Enumerable.Empty<Row>(), column);
+        private Dictionary<string, List<XElement>> IndexTableOneToMany(TableIndexedCollection tables, string tableName, int column = 0)
+        {
+            return this.IndexTableOneToMany(tables[tableName]?.Rows ?? Enumerable.Empty<Row>(), column);
+        }
 
-        private Dictionary<string, List<XElement>> IndexTableOneToMany(Table table, int column = 0) => this.IndexTableOneToMany(table?.Rows ?? Enumerable.Empty<Row>(), column);
+        private Dictionary<string, List<XElement>> IndexTableOneToMany(Table table, int column = 0)
+        {
+            return this.IndexTableOneToMany(table?.Rows ?? Enumerable.Empty<Row>(), column);
+        }
 
         private void AddChildToParent(string parentName, XElement xChild, Row row, int column)
         {
@@ -310,7 +329,10 @@ namespace WixToolset.Core.WindowsInstaller.Decompile
             }
         }
 
-        private static XAttribute XAttributeIfNotNull(string attributeName, Row row, int column) => row.IsColumnNull(column) ? null : new XAttribute(attributeName, row.FieldAsString(column));
+        private static XAttribute XAttributeIfNotNull(string attributeName, Row row, int column)
+        {
+            return row.IsColumnNull(column) ? null : new XAttribute(attributeName, row.FieldAsString(column));
+        }
 
         private static void SetAttributeIfNotNull(XElement xElement, string attributeName, string value)
         {
@@ -1578,7 +1600,10 @@ namespace WixToolset.Core.WindowsInstaller.Decompile
         /// Nests the Permission elements below their parent elements.  There are no declared foreign
         /// keys for the parents of the LockPermissions table.
         /// </remarks>
-        private void FinalizeLockPermissionsTable(TableIndexedCollection tables) => this.FinalizePermissionsTable(tables, "LockPermissions");
+        private void FinalizeLockPermissionsTable(TableIndexedCollection tables)
+        {
+            this.FinalizePermissionsTable(tables, "LockPermissions");
+        }
 
         /// <summary>
         /// Finalize the MsiLockPermissionsEx table.
@@ -1588,7 +1613,10 @@ namespace WixToolset.Core.WindowsInstaller.Decompile
         /// Nests the PermissionEx elements below their parent elements.  There are no declared foreign
         /// keys for the parents of the MsiLockPermissionsEx table.
         /// </remarks>
-        private void FinalizeMsiLockPermissionsExTable(TableIndexedCollection tables) => this.FinalizePermissionsTable(tables, "MsiLockPermissionsEx");
+        private void FinalizeMsiLockPermissionsExTable(TableIndexedCollection tables)
+        {
+            this.FinalizePermissionsTable(tables, "MsiLockPermissionsEx");
+        }
 
         private static Dictionary<string, List<string>> IndexTable(Table table, int keyColumn, int? dataColumn)
         {
@@ -2462,53 +2490,44 @@ namespace WixToolset.Core.WindowsInstaller.Decompile
             // index the rows from the extension libraries
             var indexedExtensionTables = new Dictionary<string, HashSet<string>>();
 #if TODO_DECOMPILER_EXTENSIONS
-            foreach (IDecompilerExtension extension in this.extensions)
+            foreach (var extension in this.Extensions)
             {
                 // Get the optional library from the extension with the rows to be removed.
-                Library library = extension.GetLibraryToRemove(this.tableDefinitions);
-                if (null != library)
+                var library = extension.GetLibraryToRemove(this.tableDefinitions);
+                if (library != null)
                 {
-                    foreach (var section in library.Sections)
+                    foreach (var row in library.Sections.SelectMany(s => s.Tables).SelectMany(t => t.Rows))
                     {
-                        foreach (Table table in section.Tables)
-                        {
-                            foreach (Row row in table.Rows)
-                            {
-                                string primaryKey;
-                                string tableName;
-
-                                // the Actions table needs to be handled specially
-                                if ("WixAction" == table.Name)
-                                {
-                                    primaryKey = row.FieldAsString(1);
+                        string primaryKey;
+                        string tableName;
 
-                                    if (OutputType.Module == this.outputType)
-                                    {
-                                        tableName = String.Concat("Module", row.FieldAsString(0));
-                                    }
-                                    else
-                                    {
-                                        tableName = row.FieldAsString(0);
-                                    }
-                                }
-                                else
-                                {
-                                    primaryKey = row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter);
-                                    tableName = table.Name;
-                                }
+                        // the Actions table needs to be handled specially
+                        if (table.Name == "WixAction")
+                        {
+                            primaryKey = row.FieldAsString(1);
+                            tableName = row.FieldAsString(0);
 
-                                if (null != primaryKey)
-                                {
-                                    HashSet<string> indexedExtensionRows;
-                                    if (!indexedExtensionTables.TryGetValue(tableName, out indexedExtensionRows))
-                                    {
-                                        indexedExtensionRows = new HashSet<string>();
-                                        indexedExtensionTables.Add(tableName, indexedExtensionRows);
-                                    }
+                            if (this.outputType == OutputType.Module)
+                            {
+                                tableName = "Module" + tableName;
+                            }
+                        }
+                        else
+                        {
+                            primaryKey = row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter);
+                            tableName = table.Name;
+                        }
 
-                                    indexedExtensionRows.Add(primaryKey);
-                                }
+                        if (primaryKey != null)
+                        {
+                            HashSet<string> indexedExtensionRows;
+                            if (!indexedExtensionTables.TryGetValue(tableName, out indexedExtensionRows))
+                            {
+                                indexedExtensionRows = new HashSet<string>();
+                                indexedExtensionTables.Add(tableName, indexedExtensionRows);
                             }
+
+                            indexedExtensionRows.Add(primaryKey);
                         }
                     }
                 }
diff --git a/src/wix/WixToolset.Core.WindowsInstaller/IWindowsInstallerDecompiler.cs b/src/wix/WixToolset.Core.WindowsInstaller/IWindowsInstallerDecompiler.cs
new file mode 100644
index 00000000..5bcda36c
--- /dev/null
+++ b/src/wix/WixToolset.Core.WindowsInstaller/IWindowsInstallerDecompiler.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 WixToolset.Extensibility.Data;
+
+    /// <summary>
+    /// Supports converting Windows Installer databases to source code.
+    /// </summary>
+    public interface IWindowsInstallerDecompiler
+    {
+        /// <summary>
+        /// Converts Windows Installer database back to source code.
+        /// </summary>
+        /// <param name="context">Context for decompiling.</param>
+        /// <returns>Result of decompilation.</returns>
+        IWindowsInstallerDecompileResult Decompile(IWindowsInstallerDecompileContext context);
+    }
+}
diff --git a/src/wix/WixToolset.Core.WindowsInstaller/MsiBackend.cs b/src/wix/WixToolset.Core.WindowsInstaller/MsiBackend.cs
index d1c1d3a6..f73791aa 100644
--- a/src/wix/WixToolset.Core.WindowsInstaller/MsiBackend.cs
+++ b/src/wix/WixToolset.Core.WindowsInstaller/MsiBackend.cs
@@ -47,27 +47,5 @@ namespace WixToolset.Core.WindowsInstaller
                 }
             }
         }
-
-        public IDecompileResult Decompile(IDecompileContext context)
-        {
-            var extensionManager = context.ServiceProvider.GetService<IExtensionManager>();
-
-            var backendExtensions = extensionManager.GetServices<IWindowsInstallerBackendDecompilerExtension>();
-
-            foreach (var extension in backendExtensions)
-            {
-                extension.PreBackendDecompile(context);
-            }
-
-            var command = new DecompileMsiOrMsmCommand(context, backendExtensions);
-            var result = command.Execute();
-
-            foreach (var extension in backendExtensions)
-            {
-                extension.PostBackendDecompile(result);
-            }
-
-            return result;
-        }
     }
 }
diff --git a/src/wix/WixToolset.Core.WindowsInstaller/MsmBackend.cs b/src/wix/WixToolset.Core.WindowsInstaller/MsmBackend.cs
index ea008c39..fa24745a 100644
--- a/src/wix/WixToolset.Core.WindowsInstaller/MsmBackend.cs
+++ b/src/wix/WixToolset.Core.WindowsInstaller/MsmBackend.cs
@@ -2,11 +2,7 @@
 
 namespace WixToolset.Core.WindowsInstaller
 {
-    using System;
     using WixToolset.Core.WindowsInstaller.Bind;
-    using WixToolset.Core.WindowsInstaller.Decompile;
-    using WixToolset.Core.WindowsInstaller.Unbind;
-    using WixToolset.Data;
     using WixToolset.Extensibility;
     using WixToolset.Extensibility.Data;
     using WixToolset.Extensibility.Services;
@@ -43,27 +39,5 @@ namespace WixToolset.Core.WindowsInstaller
                 throw;
             }
         }
-
-        public IDecompileResult Decompile(IDecompileContext context)
-        {
-            var extensionManager = context.ServiceProvider.GetService<IExtensionManager>();
-
-            var backendExtensions = extensionManager.GetServices<IWindowsInstallerBackendDecompilerExtension>();
-
-            foreach (var extension in backendExtensions)
-            {
-                extension.PreBackendDecompile(context);
-            }
-
-            var command = new DecompileMsiOrMsmCommand(context, backendExtensions);
-            var result = command.Execute();
-
-            foreach (var extension in backendExtensions)
-            {
-                extension.PostBackendDecompile(result);
-            }
-
-            return result;
-        }
     }
 }
diff --git a/src/wix/WixToolset.Core.WindowsInstaller/MspBackend.cs b/src/wix/WixToolset.Core.WindowsInstaller/MspBackend.cs
index 398fc780..38a4ab34 100644
--- a/src/wix/WixToolset.Core.WindowsInstaller/MspBackend.cs
+++ b/src/wix/WixToolset.Core.WindowsInstaller/MspBackend.cs
@@ -63,11 +63,6 @@ namespace WixToolset.Core.WindowsInstaller
             }
         }
 
-        public IDecompileResult Decompile(IDecompileContext context)
-        {
-            throw new NotImplementedException();
-        }
-
 #if TODO_PATCHING
         public Intermediate Unbind(IUnbindContext context)
         {
diff --git a/src/wix/WixToolset.Core/DecompileContext.cs b/src/wix/WixToolset.Core.WindowsInstaller/WindowsInstallerDecompileContext.cs
index a7ec03fd..1428a469 100644
--- a/src/wix/WixToolset.Core/DecompileContext.cs
+++ b/src/wix/WixToolset.Core.WindowsInstaller/WindowsInstallerDecompileContext.cs
@@ -1,17 +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
+namespace WixToolset.Core.WindowsInstaller
 {
     using System;
     using System.Collections.Generic;
     using WixToolset.Data;
     using WixToolset.Extensibility;
     using WixToolset.Extensibility.Data;
-    using WixToolset.Extensibility.Services;
 
-    internal class DecompileContext : IDecompileContext
+    internal class WindowsInstallerDecompileContext : IWindowsInstallerDecompileContext
     {
-        internal DecompileContext(IServiceProvider serviceProvider)
+        internal WindowsInstallerDecompileContext(IServiceProvider serviceProvider)
         {
             this.ServiceProvider = serviceProvider;
         }
@@ -22,7 +21,7 @@ namespace WixToolset.Core
 
         public OutputType DecompileType { get; set; }
 
-        public IReadOnlyCollection<IDecompilerExtension> Extensions { get; set; }
+        public IReadOnlyCollection<IWindowsInstallerDecompilerExtension> Extensions { get; set; }
 
         public string ExtractFolder { get; set; }
 
@@ -40,6 +39,8 @@ namespace WixToolset.Core
 
         public bool SuppressDroppingEmptyTables { get; set; }
 
+        public bool SuppressRelativeActionSequencing { get; set; }
+
         public bool SuppressExtractCabinets { get; set; }
 
         public bool SuppressUI { get; set; }
diff --git a/src/wix/WixToolset.Core/DecompileResult.cs b/src/wix/WixToolset.Core.WindowsInstaller/WindowsInstallerDecompileResult.cs
index fc24cab7..69363286 100644
--- a/src/wix/WixToolset.Core/DecompileResult.cs
+++ b/src/wix/WixToolset.Core.WindowsInstaller/WindowsInstallerDecompileResult.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.Core
+namespace WixToolset.Core.WindowsInstaller
 { 
     using System.Collections.Generic;
     using System.Xml.Linq;
     using WixToolset.Data;
     using WixToolset.Extensibility.Data;
 
-    internal class DecompileResult : IDecompileResult
+    internal class WindowsInstallerDecompileResult : IWindowsInstallerDecompileResult
     {
         public XDocument Document { get; set; }
 
diff --git a/src/wix/WixToolset.Core/Decompiler.cs b/src/wix/WixToolset.Core.WindowsInstaller/WindowsInstallerDecompiler.cs
index 859f582b..10420010 100644
--- a/src/wix/WixToolset.Core/Decompiler.cs
+++ b/src/wix/WixToolset.Core.WindowsInstaller/WindowsInstallerDecompiler.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.Core
+namespace WixToolset.Core.WindowsInstaller
 {
     using System;
+    using WixToolset.Core.WindowsInstaller.Decompile;
     using WixToolset.Extensibility;
     using WixToolset.Extensibility.Data;
     using WixToolset.Extensibility.Services;
@@ -10,16 +11,16 @@ namespace WixToolset.Core
     /// <summary>
     /// Decompiler of the WiX toolset.
     /// </summary>
-    internal class Decompiler : IDecompiler
+    internal class WindowsInstallerDecompiler : IWindowsInstallerDecompiler
     {
-        internal Decompiler(IServiceProvider serviceProvider)
+        internal WindowsInstallerDecompiler(IServiceProvider serviceProvider)
         {
             this.ServiceProvider = serviceProvider;
         }
 
         public IServiceProvider ServiceProvider { get; }
 
-        public IDecompileResult Decompile(IDecompileContext context)
+        public IWindowsInstallerDecompileResult Decompile(IWindowsInstallerDecompileContext context)
         {
             // Pre-decompile.
             //
@@ -30,7 +31,8 @@ namespace WixToolset.Core
 
             // Decompile.
             //
-            var result = this.BackendDecompile(context);
+            var command = new DecompileMsiOrMsmCommand(context);
+            var result = command.Execute();
 
             if (result != null)
             {
@@ -44,25 +46,5 @@ namespace WixToolset.Core
 
             return result;
         }
-
-        private IDecompileResult BackendDecompile(IDecompileContext context)
-        {
-            var extensionManager = context.ServiceProvider.GetService<IExtensionManager>();
-
-            var backendFactories = extensionManager.GetServices<IBackendFactory>();
-
-            foreach (var factory in backendFactories)
-            {
-                if (factory.TryCreateBackend(context.DecompileType.ToString(), context.OutputPath, out var backend))
-                {
-                    var result = backend.Decompile(context);
-                    return result;
-                }
-            }
-
-            // TODO: messaging that a backend could not be found to decompile the decompile type?
-
-            return null;
-        }
     }
 }
diff --git a/src/wix/WixToolset.Core.WindowsInstaller/WixToolsetCoreServiceProviderExtensions.cs b/src/wix/WixToolset.Core.WindowsInstaller/WixToolsetCoreServiceProviderExtensions.cs
index e686fa49..d064aed1 100644
--- a/src/wix/WixToolset.Core.WindowsInstaller/WixToolsetCoreServiceProviderExtensions.cs
+++ b/src/wix/WixToolset.Core.WindowsInstaller/WixToolsetCoreServiceProviderExtensions.cs
@@ -5,6 +5,7 @@ namespace WixToolset.Core.WindowsInstaller
     using System;
     using System.Collections.Generic;
     using WixToolset.Core.WindowsInstaller.ExtensibilityServices;
+    using WixToolset.Extensibility.Data;
     using WixToolset.Extensibility.Services;
 
     /// <summary>
@@ -31,6 +32,11 @@ namespace WixToolset.Core.WindowsInstaller
         {
             // Singletons.
             coreProvider.AddService((provider, singletons) => AddSingleton<IWindowsInstallerBackendHelper>(singletons, new WindowsInstallerBackendHelper(provider)));
+
+            // Transients.
+            coreProvider.AddService<IWindowsInstallerDecompiler>((provider, singletons) => new WindowsInstallerDecompiler(provider));
+            coreProvider.AddService<IWindowsInstallerDecompileContext>((provider, singletons) => new WindowsInstallerDecompileContext(provider));
+            coreProvider.AddService<IWindowsInstallerDecompileResult>((provider, singletons) => new WindowsInstallerDecompileResult());
         }
 
         private static T AddSingleton<T>(Dictionary<Type, object> singletons, T service) where T : class
diff --git a/src/wix/WixToolset.Core/CommandLine/CommandLine.cs b/src/wix/WixToolset.Core/CommandLine/CommandLine.cs
index cd3b2fe4..0921f9ff 100644
--- a/src/wix/WixToolset.Core/CommandLine/CommandLine.cs
+++ b/src/wix/WixToolset.Core/CommandLine/CommandLine.cs
@@ -9,14 +9,6 @@ namespace WixToolset.Core.CommandLine
     using WixToolset.Extensibility.Data;
     using WixToolset.Extensibility.Services;
 
-    internal enum CommandTypes
-    {
-        Unknown,
-        Build,
-        Preprocess,
-        Decompile,
-    }
-
     internal class CommandLine : ICommandLine
     {
         public CommandLine(IServiceProvider serviceProvider)
@@ -154,18 +146,9 @@ namespace WixToolset.Core.CommandLine
             }
             else
             {
-                if (Enum.TryParse(arg, true, out CommandTypes commandType))
+                if ("build".Equals(arg, StringComparison.OrdinalIgnoreCase))
                 {
-                    switch (commandType)
-                    {
-                        case CommandTypes.Build:
-                            command = new BuildCommand(this.ServiceProvider);
-                            break;
-
-                        case CommandTypes.Decompile:
-                            command = new DecompileCommand(this.ServiceProvider);
-                            break;
-                    }
+                    command = new BuildCommand(this.ServiceProvider);
                 }
                 else
                 {
@@ -175,8 +158,6 @@ namespace WixToolset.Core.CommandLine
                         {
                             break;
                         }
-
-                        command = null;
                     }
                 }
             }
diff --git a/src/wix/WixToolset.Core/CommandLine/CommandLineParser.cs b/src/wix/WixToolset.Core/CommandLine/CommandLineParser.cs
index 015d3e62..7e6e7cac 100644
--- a/src/wix/WixToolset.Core/CommandLine/CommandLineParser.cs
+++ b/src/wix/WixToolset.Core/CommandLine/CommandLineParser.cs
@@ -41,12 +41,16 @@ namespace WixToolset.Core.CommandLine
             return argument;
         }
 
-        public void GetArgumentAsFilePathOrError(string argument, string fileType, IList<string> paths)
+        public bool GetArgumentAsFilePathOrError(string argument, string fileType, IList<string> paths)
         {
-            foreach (var path in this.GetFiles(argument, fileType))
+            var files = this.GetFiles(argument, fileType);
+
+            foreach (var path in files)
             {
                 paths.Add(path);
             }
+
+            return files.Length > 0;
         }
 
         public string GetNextArgumentOrError(string commandLineSwitch)
@@ -140,6 +144,23 @@ namespace WixToolset.Core.CommandLine
             return false;
         }
 
+        public string PeekNextArgument()
+        {
+            return this.TryPeekNextArgument(out var argument) ? argument : null;
+        }
+
+        public bool TryPeekNextArgument(out string argument)
+        {
+            if (this.RemainingArguments.Count > 0)
+            {
+                argument = this.RemainingArguments.Peek();
+                return true;
+            }
+
+            argument = null;
+            return false;
+        }
+
         private bool TryGetNextNonSwitchArgumentOrError(out string arg)
         {
             var result = this.TryGetNextSwitchOrArgument(out arg);
diff --git a/src/wix/WixToolset.Core/CommandLine/DecompileCommand.cs b/src/wix/WixToolset.Core/CommandLine/DecompileCommand.cs
deleted file mode 100644
index 22853f86..00000000
--- a/src/wix/WixToolset.Core/CommandLine/DecompileCommand.cs
+++ /dev/null
@@ -1,202 +0,0 @@
-// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
-
-namespace WixToolset.Core.CommandLine
-{
-    using System;
-    using System.IO;
-    using System.Threading;
-    using System.Threading.Tasks;
-    using System.Xml.Linq;
-    using WixToolset.Data;
-    using WixToolset.Extensibility;
-    using WixToolset.Extensibility.Data;
-    using WixToolset.Extensibility.Services;
-
-    internal class DecompileCommand : ICommandLineCommand
-    {
-        private readonly CommandLine commandLine;
-
-        public DecompileCommand(IServiceProvider serviceProvider)
-        {
-            this.ServiceProvider = serviceProvider;
-            this.Messaging = serviceProvider.GetService<IMessaging>();
-            this.commandLine = new CommandLine(this.Messaging);
-        }
-
-        public bool ShowHelp
-        {
-            get { return this.commandLine.ShowHelp; }
-            set { this.commandLine.ShowHelp = value; }
-        }
-
-        public bool ShowLogo
-        {
-            get { return this.commandLine.ShowLogo; }
-            set { this.commandLine.ShowLogo = value; }
-        }
-
-        // Stop parsing when we've decided to show help.
-        public bool StopParsing => this.commandLine.ShowHelp;
-
-        private IServiceProvider ServiceProvider { get; }
-
-        public IMessaging Messaging { get; }
-
-        public Task<int> ExecuteAsync(CancellationToken _)
-        {
-            if (this.commandLine.ShowHelp || String.IsNullOrEmpty(this.commandLine.DecompileFilePath))
-            {
-                Console.WriteLine("TODO: Show decompile command help");
-                return Task.FromResult(-1);
-            }
-
-            var context = this.ServiceProvider.GetService<IDecompileContext>();
-            context.Extensions = this.ServiceProvider.GetService<IExtensionManager>().GetServices<IDecompilerExtension>();
-            context.DecompilePath = this.commandLine.DecompileFilePath;
-            context.DecompileType = this.commandLine.CalculateDecompileType();
-            context.IntermediateFolder = this.commandLine.CalculateIntermedateFolder();
-            context.OutputPath = this.commandLine.CalculateOutputPath();
-
-            try
-            {
-                var decompiler = this.ServiceProvider.GetService<IDecompiler>();
-                var result = decompiler.Decompile(context);
-
-                if (!this.Messaging.EncounteredError)
-                {
-                    Directory.CreateDirectory(Path.GetDirectoryName(Path.GetFullPath(context.OutputPath)));
-                    result.Document.Save(context.OutputPath, SaveOptions.OmitDuplicateNamespaces);
-                }
-            }
-            catch (WixException e)
-            {
-                this.Messaging.Write(e.Error);
-            }
-
-            if (this.Messaging.EncounteredError)
-            {
-                return Task.FromResult(1);
-            }
-
-            return Task.FromResult(0);
-        }
-
-        public bool TryParseArgument(ICommandLineParser parser, string argument)
-        {
-            return this.commandLine.TryParseArgument(argument, parser);
-        }
-
-        private class CommandLine
-        {
-            public CommandLine(IMessaging messaging)
-            {
-                this.Messaging = messaging;
-            }
-
-            private IMessaging Messaging { get; }
-
-            public string DecompileFilePath { get; private set; }
-
-            public string DecompileType { get; private set; }
-
-            public Platform Platform { get; private set; }
-
-            public bool ShowLogo { get; set; }
-
-            public bool ShowHelp { get; set; }
-
-            public string IntermediateFolder { get; private set; }
-
-            public string OutputFile { get; private set; }
-
-            public bool TryParseArgument(string arg, ICommandLineParser parser)
-            {
-                if (parser.IsSwitch(arg))
-                {
-                    var parameter = arg.Substring(1);
-                    switch (parameter.ToLowerInvariant())
-                    {
-                    case "intermediatefolder":
-                        this.IntermediateFolder = parser.GetNextArgumentAsDirectoryOrError(arg);
-                        return true;
-
-                    case "o":
-                    case "out":
-                        this.OutputFile = parser.GetNextArgumentAsFilePathOrError(arg);
-                        return true;
-                    }
-                }
-                else
-                {
-                    if (String.IsNullOrEmpty(this.DecompileFilePath))
-                    {
-                        this.DecompileFilePath = parser.GetArgumentAsFilePathOrError(arg, "decompile file");
-                        return true;
-                    }
-                    else if (String.IsNullOrEmpty(this.OutputFile))
-                    {
-                        this.OutputFile = parser.GetArgumentAsFilePathOrError(arg, "output file");
-                        return true;
-                    }
-                }
-
-                return false;
-            }
-
-            public OutputType CalculateDecompileType()
-            {
-                if (String.IsNullOrEmpty(this.DecompileType))
-                {
-                    this.DecompileType = Path.GetExtension(this.DecompileFilePath);
-                }
-
-                switch (this.DecompileType.ToLowerInvariant())
-                {
-                case "bundle":
-                case ".exe":
-                    return OutputType.Bundle;
-
-                case "library":
-                case ".wixlib":
-                    return OutputType.Library;
-
-                case "module":
-                case ".msm":
-                    return OutputType.Module;
-
-                case "patch":
-                case ".msp":
-                    return OutputType.Patch;
-
-                case ".pcp":
-                    return OutputType.PatchCreation;
-
-                case "product":
-                case "package":
-                case ".msi":
-                    return OutputType.Product;
-
-                case "transform":
-                case ".mst":
-                    return OutputType.Transform;
-
-                case "intermediatepostlink":
-                case ".wixipl":
-                    return OutputType.IntermediatePostLink;
-                }
-
-                return OutputType.Unknown;
-            }
-
-            public string CalculateIntermedateFolder()
-            {
-                return String.IsNullOrEmpty(this.IntermediateFolder) ? Path.GetTempPath() : this.IntermediateFolder;
-            }
-
-            public string CalculateOutputPath()
-            {
-                return String.IsNullOrEmpty(this.OutputFile) ? Path.ChangeExtension(this.DecompileFilePath, ".wxs") : this.OutputFile;
-            }
-        }
-    }
-}
diff --git a/src/wix/WixToolset.Core/IDecompiler.cs b/src/wix/WixToolset.Core/IDecompiler.cs
deleted file mode 100644
index 74ec26de..00000000
--- a/src/wix/WixToolset.Core/IDecompiler.cs
+++ /dev/null
@@ -1,12 +0,0 @@
-// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
-
-namespace WixToolset.Core
-{
-    using WixToolset.Extensibility.Data;
-
-#pragma warning disable 1591 // TODO: add documentation
-    public interface IDecompiler
-    {
-        IDecompileResult Decompile(IDecompileContext context);
-    }
-}
diff --git a/src/wix/WixToolset.Core/WixToolsetServiceProvider.cs b/src/wix/WixToolset.Core/WixToolsetServiceProvider.cs
index 9fbf6717..525b9dd9 100644
--- a/src/wix/WixToolset.Core/WixToolsetServiceProvider.cs
+++ b/src/wix/WixToolset.Core/WixToolsetServiceProvider.cs
@@ -40,14 +40,12 @@ namespace WixToolset.Core
             this.AddService<ILinkContext>((provider, singletons) => new LinkContext(provider));
             this.AddService<IResolveContext>((provider, singletons) => new ResolveContext(provider));
             this.AddService<IBindContext>((provider, singletons) => new BindContext(provider));
-            this.AddService<IDecompileContext>((provider, singletons) => new DecompileContext(provider));
             this.AddService<ILayoutContext>((provider, singletons) => new LayoutContext(provider));
 
             this.AddService<IBindFileWithPath>((provider, singletons) => new BindFileWithPath());
             this.AddService<IBindPath>((provider, singletons) => new BindPath());
             this.AddService<IBindResult>((provider, singletons) => new BindResult());
             this.AddService<IComponentKeyPath>((provider, singletons) => new ComponentKeyPath());
-            this.AddService<IDecompileResult>((provider, singletons) => new DecompileResult());
             this.AddService<IIncludedFile>((provider, singletons) => new IncludedFile());
             this.AddService<IPreprocessResult>((provider, singletons) => new PreprocessResult());
             this.AddService<IResolvedDirectory>((provider, singletons) => new ResolvedDirectory());
@@ -58,7 +56,6 @@ namespace WixToolset.Core
 
             this.AddService<IBinder>((provider, singletons) => new Binder(provider));
             this.AddService<ICompiler>((provider, singletons) => new Compiler(provider));
-            this.AddService<IDecompiler>((provider, singletons) => new Decompiler(provider));
             this.AddService<ILayoutCreator>((provider, singletons) => new LayoutCreator(provider));
             this.AddService<IPreprocessor>((provider, singletons) => new Preprocessor(provider));
             this.AddService<ILibrarian>((provider, singletons) => new Librarian(provider));
diff --git a/src/wix/test/WixToolsetTest.Converters/ProductPackageFixture.cs b/src/wix/test/WixToolsetTest.Converters/ProductPackageFixture.cs
index e01b9789..5ad7ef6f 100644
--- a/src/wix/test/WixToolsetTest.Converters/ProductPackageFixture.cs
+++ b/src/wix/test/WixToolsetTest.Converters/ProductPackageFixture.cs
@@ -249,7 +249,7 @@ namespace WixToolsetTest.Converters
                 var v3msiPath = Path.Combine(folder, "TypicalV3.msi");
                 var result = WixRunner.Execute(new[]
                 {
-                    "decompile", v3msiPath,
+                    "msi", "decompile", v3msiPath,
                     "-intermediateFolder", intermediateFolder,
                     "-o", decompiledWxsPath
                 });
diff --git a/src/wix/test/WixToolsetTest.CoreIntegration/CustomTableFixture.cs b/src/wix/test/WixToolsetTest.CoreIntegration/CustomTableFixture.cs
index b9a6185d..1be7d9ab 100644
--- a/src/wix/test/WixToolsetTest.CoreIntegration/CustomTableFixture.cs
+++ b/src/wix/test/WixToolsetTest.CoreIntegration/CustomTableFixture.cs
@@ -219,7 +219,7 @@ namespace WixToolsetTest.CoreIntegration
 
                 result = WixRunner.Execute(new[]
                 {
-                    "decompile", msiPath,
+                    "msi", "decompile", msiPath,
                     "-sw1060",
                     "-intermediateFolder", intermediateFolder,
                     "-o", decompiledWxsPath
diff --git a/src/wix/test/WixToolsetTest.CoreIntegration/DecompileFixture.cs b/src/wix/test/WixToolsetTest.CoreIntegration/DecompileFixture.cs
index e87bbfee..b43d2033 100644
--- a/src/wix/test/WixToolsetTest.CoreIntegration/DecompileFixture.cs
+++ b/src/wix/test/WixToolsetTest.CoreIntegration/DecompileFixture.cs
@@ -20,7 +20,7 @@ namespace WixToolsetTest.CoreIntegration
 
                 var result = WixRunner.Execute(new[]
                 {
-                    "decompile",
+                    "msi", "decompile",
                     Path.Combine(folder, msiName),
                     "-intermediateFolder", intermediateFolder,
                     "-o", outputPath