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