Import code from old v4 repo

90 files changed, 41905 insertions, 0 deletions

diff --git a/src/Samples/ManagedBundleRunner/BundleErrorEventArgs.cs b/src/Samples/ManagedBundleRunner/BundleErrorEventArgs.cs
new file mode 100644
index 00000000..2c377326
--- /dev/null
+++ b/src/Samples/ManagedBundleRunner/BundleErrorEventArgs.cs
@@ -0,0 +1,33 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace Wix.Samples
+{
+    using System;
+
+    /// <summary>
+    /// Arguments provided when bundle encounters an error.
+    /// </summary>
+    [Serializable]
+    public class BundleErrorEventArgs : EventArgs
+    {
+        /// <summary>
+        /// Gets the error code.
+        /// </summary>
+        public int Code { get; set; }
+
+        /// <summary>
+        /// Gets the error message.
+        /// </summary>
+        public string Message { get; set; }
+
+        /// <summary>
+        /// Gets the recommended display flags for an error dialog.
+        /// </summary>
+        public int UIHint { get; set; }
+
+        /// <summary>
+        /// Gets or sets the <see cref="Result"/> of the operation. This is passed back to the bundle.
+        /// </summary>
+        public BundleResult Result { get; set; }
+    }
+}
diff --git a/src/Samples/ManagedBundleRunner/BundleProgressEventArgs.cs b/src/Samples/ManagedBundleRunner/BundleProgressEventArgs.cs
new file mode 100644
index 00000000..ed42b5b1
--- /dev/null
+++ b/src/Samples/ManagedBundleRunner/BundleProgressEventArgs.cs
@@ -0,0 +1,23 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace Wix.Samples
+{
+    using System;
+
+    /// <summary>
+    /// Arguments provided when bundle progress is updated.
+    /// </summary>
+    [Serializable]
+    public class BundleProgressEventArgs : EventArgs
+    {
+        /// <summary>
+        /// Gets the percentage from 0 to 100 completed for a bundle.
+        /// </summary>
+        public int Progress { get; set; }
+
+        /// <summary>
+        /// Gets or sets the <see cref="Result"/> of the operation. This is passed back to the bundle.
+        /// </summary>
+        public BundleResult Result { get; set; }
+    }
+}
diff --git a/src/Samples/ManagedBundleRunner/BundleResult.cs b/src/Samples/ManagedBundleRunner/BundleResult.cs
new file mode 100644
index 00000000..c32644f4
--- /dev/null
+++ b/src/Samples/ManagedBundleRunner/BundleResult.cs
@@ -0,0 +1,24 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace Wix.Samples
+{
+    /// <summary>
+    /// Result codes.
+    /// </summary>
+    public enum BundleResult
+    {
+        Error = -1,
+        None,
+        Ok,
+        Cancel,
+        Abort,
+        Retry,
+        Ignore,
+        Yes,
+        No,
+        Close,
+        Help,
+        TryAgain,
+        Continue,
+    }
+}
diff --git a/src/Samples/ManagedBundleRunner/BundleRunner.cs b/src/Samples/ManagedBundleRunner/BundleRunner.cs
new file mode 100644
index 00000000..e2089787
--- /dev/null
+++ b/src/Samples/ManagedBundleRunner/BundleRunner.cs
@@ -0,0 +1,212 @@
+// 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 Wix.Samples
+{
+    using System;
+    using System.Diagnostics;
+    using System.IO.Pipes;
+    using System.Text;
+    using System.Threading;
+
+    /// <summary>
+    /// Runs a bundle with provided command-line.
+    /// </summary>
+    public class BundleRunner
+    {
+        /// <summary>
+        /// Creates a runner for the provided bundle.
+        /// </summary>
+        /// <param name="bundle">Path to the bundle to run.</param>
+        public BundleRunner(string bundle)
+        {
+            this.Path = bundle;
+        }
+
+        /// <summary>
+        /// Fired when the bundle encounters an error.
+        /// </summary>
+        public event EventHandler<BundleErrorEventArgs> Error;
+
+        /// <summary>
+        /// Fired when the bundle progress is udpated.
+        /// </summary>
+        public event EventHandler<BundleProgressEventArgs> Progress;
+
+        /// <summary>
+        /// Gets the path to the bundle to run.
+        /// </summary>
+        public string Path { get; private set; }
+
+        /// <summary>
+        /// Runs the bundle with the provided command-line.
+        /// </summary>
+        /// <param name="commandLine">Optional command-line to pass to the bundle.</param>
+        /// <returns>Exit code from the bundle.</returns>
+        public int Run(string commandLine = null)
+        {
+            WaitHandle[] waits = new WaitHandle[] { new ManualResetEvent(false), new ManualResetEvent(false) };
+            int returnCode = 0;
+            int pid = Process.GetCurrentProcess().Id;
+            string pipeName = String.Concat("bpe_", pid);
+            string pipeSecret = Guid.NewGuid().ToString("N");
+
+            using (NamedPipeServerStream pipe = new NamedPipeServerStream(pipeName, PipeDirection.InOut, 1))
+            {
+                using (Process bundleProcess = new Process())
+                {
+                    bundleProcess.StartInfo.FileName = this.Path;
+                    bundleProcess.StartInfo.Arguments = String.Format("{0} -burn.embedded {1} {2} {3}", commandLine ?? String.Empty, pipeName, pipeSecret, pid);
+                    bundleProcess.StartInfo.UseShellExecute = false;
+                    bundleProcess.StartInfo.CreateNoWindow = true;
+                    bundleProcess.Start();
+
+                    Connect(pipe, pipeSecret, pid, bundleProcess.Id);
+
+                    PumpMessages(pipe);
+
+                    bundleProcess.WaitForExit();
+                    returnCode = bundleProcess.ExitCode;
+                }
+            }
+
+            return returnCode;
+        }
+
+        /// <summary>
+        /// Called when bundle encounters an error.
+        /// </summary>
+        /// <param name="e">Additional arguments for this event.</param>
+        protected virtual void OnError(BundleErrorEventArgs e)
+        {
+            EventHandler<BundleErrorEventArgs> handler = this.Error;
+            if (handler != null)
+            {
+                handler(this, e);
+            }
+        }
+
+        /// <summary>
+        /// Called when bundle progress is updated.
+        /// </summary>
+        /// <param name="e">Additional arguments for this event.</param>
+        protected virtual void OnProgress(BundleProgressEventArgs e)
+        {
+            EventHandler<BundleProgressEventArgs> handler = this.Progress;
+            if (handler != null)
+            {
+                handler(this, e);
+            }
+        }
+
+        private void Connect(NamedPipeServerStream pipe, string pipeSecret, int pid, int childPid)
+        {
+            pipe.WaitForConnection();
+
+            WriteSecretToPipe(pipe, pipeSecret);
+
+            WriteNumberToPipe(pipe, (uint)pid);
+
+            uint ack = ReadNumberFromPipe(pipe);
+            // This is not true when bundle is run under a debugger
+            //if (ack != childPid)
+            //{
+            //    throw new ApplicationException("Incorrect child process.");
+            //}
+        }
+
+        private void PumpMessages(NamedPipeServerStream pipe)
+        {
+            uint messageId;
+            while (TryReadNumberFromPipe(pipe, out messageId))
+            {
+                uint messageSize = ReadNumberFromPipe(pipe);
+
+                BundleResult result = BundleResult.None;
+                switch (messageId)
+                {
+                    case 1: //error
+                        result = ProcessErrorMessage(pipe);
+                        break;
+
+                    case 2: // progress
+                        result = ProcessProgressMessage(pipe);
+                        break;
+
+                    default: // unknown message, do nothing.
+                        break;
+                }
+
+                CompleteMessage(pipe, result);
+            }
+        }
+
+        private BundleResult ProcessErrorMessage(NamedPipeServerStream pipe)
+        {
+            BundleErrorEventArgs e = new BundleErrorEventArgs();
+            e.Code = (int)ReadNumberFromPipe(pipe);
+            e.Message = ReadStringFromPipe(pipe);
+            e.UIHint = (int)ReadNumberFromPipe(pipe);
+
+            this.OnError(e);
+
+            return e.Result;
+        }
+
+        private BundleResult ProcessProgressMessage(NamedPipeServerStream pipe)
+        {
+            ReadNumberFromPipe(pipe); // eat the first progress number because it is always zero.
+
+            BundleProgressEventArgs e = new BundleProgressEventArgs();
+            e.Progress = (int)ReadNumberFromPipe(pipe);
+
+            this.OnProgress(e);
+
+            return e.Result;
+        }
+
+        private void CompleteMessage(NamedPipeServerStream pipe, BundleResult result)
+        {
+            uint complete = 0xF0000002;
+            WriteNumberToPipe(pipe, complete);
+            WriteNumberToPipe(pipe, 4); // size of message data
+            WriteNumberToPipe(pipe, (uint)result);
+        }
+
+        private uint ReadNumberFromPipe(NamedPipeServerStream pipe)
+        {
+            byte[] buffer = new byte[4];
+            pipe.Read(buffer, 0, buffer.Length);
+            return BitConverter.ToUInt32(buffer, 0);
+        }
+
+        private string ReadStringFromPipe(NamedPipeServerStream pipe)
+        {
+            uint length = ReadNumberFromPipe(pipe);
+
+            byte[] buffer = new byte[length * 2];
+            pipe.Read(buffer, 0, buffer.Length);
+
+            return Encoding.Unicode.GetString(buffer);
+        }
+
+        private bool TryReadNumberFromPipe(NamedPipeServerStream pipe, out uint value)
+        {
+            value = ReadNumberFromPipe(pipe); // reading will not block and return zero if pipe is not connected.
+            return pipe.IsConnected;
+        }
+
+        private void WriteNumberToPipe(NamedPipeServerStream pipe, uint value)
+        {
+            byte[] buffer = BitConverter.GetBytes(value);
+            pipe.Write(buffer, 0, buffer.Length);
+        }
+
+        private void WriteSecretToPipe(NamedPipeServerStream pipe, string secret)
+        {
+            byte[] buffer = Encoding.Unicode.GetBytes(secret);
+
+            WriteNumberToPipe(pipe, (uint)buffer.Length);
+            pipe.Write(buffer, 0, buffer.Length);
+        }
+    }
+}
diff --git a/src/Samples/runbundle/AssemblyInfo.cs b/src/Samples/runbundle/AssemblyInfo.cs
new file mode 100644
index 00000000..3a66d5e3
--- /dev/null
+++ b/src/Samples/runbundle/AssemblyInfo.cs
@@ -0,0 +1,12 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+using System;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+[assembly: AssemblyTitle("Executable to demonstrate Bundle Runner Sample")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyCulture("")]
+[assembly: CLSCompliant(true)]
+[assembly: ComVisible(false)]
diff --git a/src/Samples/runbundle/Program.cs b/src/Samples/runbundle/Program.cs
new file mode 100644
index 00000000..8edca5dc
--- /dev/null
+++ b/src/Samples/runbundle/Program.cs
@@ -0,0 +1,47 @@
+// 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 Wix.Samples
+{
+    using System;
+    using System.Linq;
+    using Wix.Samples;
+
+    /// <summary>
+    /// Example executable that installs then immediately uninstalls a bundle showing progress.
+    /// </summary>
+    class Program
+    {
+        static int Main(string[] args)
+        {
+            if (args.Length == 0)
+            {
+                Console.WriteLine("Must provide the path to the bundle to install then uninstall.");
+                return -1;
+            }
+
+            BundleRunner runner = new BundleRunner(args[0]);
+            runner.Error += Program.OnError;
+            runner.Progress += Program.OnProgress;
+
+            Console.WriteLine("Installing: {0}", runner.Path);
+            int exitCode = runner.Run(String.Join(" ", args.Skip(1).ToArray()));
+            if (0 == exitCode)
+            {
+                Console.WriteLine("\r\nUninstalling: {0}", runner.Path);
+                exitCode = runner.Run("-uninstall");
+            }
+
+            return exitCode;
+        }
+
+        static void OnError(object sender, BundleErrorEventArgs e)
+        {
+            Console.WriteLine("error: {0}, uiHint: {1}, message: {2}", e.Code, e.UIHint, e.Message);
+        }
+
+        static void OnProgress(object sender, BundleProgressEventArgs e)
+        {
+            Console.WriteLine("progresss: {0}%", e.Progress);
+        }
+    }
+}
diff --git a/src/engine/EngineForApplication.cpp b/src/engine/EngineForApplication.cpp
new file mode 100644
index 00000000..eda5fc64
--- /dev/null
+++ b/src/engine/EngineForApplication.cpp
@@ -0,0 +1,894 @@
+// 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.
+
+#include "precomp.h"
+
+static HRESULT BAEngineGetPackageCount(
+    __in BOOTSTRAPPER_ENGINE_CONTEXT* pContext,
+    __in BAENGINE_GETPACKAGECOUNT_ARGS* /*pArgs*/,
+    __in BAENGINE_GETPACKAGECOUNT_RESULTS* pResults
+    )
+{
+    HRESULT hr = S_OK;
+    DWORD* pcPackages = &pResults->cPackages;
+
+    *pcPackages = pContext->pEngineState->packages.cPackages;
+
+    return hr;
+}
+
+static HRESULT BAEngineGetVariableNumeric(
+    __in BOOTSTRAPPER_ENGINE_CONTEXT* pContext,
+    __in BAENGINE_GETVARIABLENUMERIC_ARGS* pArgs,
+    __in BAENGINE_GETVARIABLENUMERIC_RESULTS* pResults
+    )
+{
+    HRESULT hr = S_OK;
+    LPCWSTR wzVariable = pArgs->wzVariable;
+    LONGLONG* pllValue = &pResults->llValue;
+
+    if (wzVariable && *wzVariable)
+    {
+        hr = VariableGetNumeric(&pContext->pEngineState->variables, wzVariable, pllValue);
+    }
+    else
+    {
+        hr = E_INVALIDARG;
+    }
+
+    return hr;
+}
+
+static HRESULT BAEngineGetVariableString(
+    __in BOOTSTRAPPER_ENGINE_CONTEXT* pContext,
+    __in BAENGINE_GETVARIABLESTRING_ARGS* pArgs,
+    __in BAENGINE_GETVARIABLESTRING_RESULTS* pResults
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR sczValue = NULL;
+    size_t cchRemaining = 0;
+    LPCWSTR wzVariable = pArgs->wzVariable;
+    LPWSTR wzValue = pResults->wzValue;
+    DWORD* pcchValue = &pResults->cchValue;
+
+    if (wzVariable && *wzVariable)
+    {
+        hr = VariableGetString(&pContext->pEngineState->variables, wzVariable, &sczValue);
+        if (SUCCEEDED(hr))
+        {
+            if (wzValue)
+            {
+                hr = ::StringCchCopyExW(wzValue, *pcchValue, sczValue, NULL, &cchRemaining, STRSAFE_FILL_BEHIND_NULL);
+                if (STRSAFE_E_INSUFFICIENT_BUFFER == hr)
+                {
+                    hr = E_MOREDATA;
+
+                    ::StringCchLengthW(sczValue, STRSAFE_MAX_CCH, &cchRemaining);
+                    *pcchValue = cchRemaining + 1;
+                }
+            }
+            else
+            {
+                hr = E_MOREDATA;
+
+                ::StringCchLengthW(sczValue, STRSAFE_MAX_CCH, &cchRemaining);
+                *pcchValue = cchRemaining + 1;
+            }
+        }
+    }
+    else
+    {
+        hr = E_INVALIDARG;
+    }
+
+    StrSecureZeroFreeString(sczValue);
+    return hr;
+}
+
+static HRESULT BAEngineGetVariableVersion(
+    __in BOOTSTRAPPER_ENGINE_CONTEXT* pContext,
+    __in BAENGINE_GETVARIABLEVERSION_ARGS* pArgs,
+    __in BAENGINE_GETVARIABLEVERSION_RESULTS* pResults
+    )
+{
+    HRESULT hr = S_OK;
+    LPCWSTR wzVariable = pArgs->wzVariable;
+    DWORD64* pqwValue = &pResults->qwValue;
+
+    if (wzVariable && *wzVariable)
+    {
+        hr = VariableGetVersion(&pContext->pEngineState->variables, wzVariable, pqwValue);
+    }
+    else
+    {
+        hr = E_INVALIDARG;
+    }
+
+    return hr;
+}
+
+static HRESULT BAEngineFormatString(
+    __in BOOTSTRAPPER_ENGINE_CONTEXT* pContext,
+    __in BAENGINE_FORMATSTRING_ARGS* pArgs,
+    __in BAENGINE_FORMATSTRING_RESULTS* pResults
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR sczValue = NULL;
+    DWORD cchValue = 0;
+    LPCWSTR wzIn = pArgs->wzIn;
+    LPWSTR wzOut = pResults->wzOut;
+    DWORD* pcchOut = &pResults->cchOut;
+
+    if (wzIn && *wzIn)
+    {
+        hr = VariableFormatString(&pContext->pEngineState->variables, wzIn, &sczValue, &cchValue);
+        if (SUCCEEDED(hr))
+        {
+            if (wzOut)
+            {
+                hr = ::StringCchCopyExW(wzOut, *pcchOut, sczValue, NULL, NULL, STRSAFE_FILL_BEHIND_NULL);
+                if (FAILED(hr))
+                {
+                    *pcchOut = cchValue;
+                    if (STRSAFE_E_INSUFFICIENT_BUFFER == hr)
+                    {
+                        hr = E_MOREDATA;
+                    }
+                }
+            }
+            else
+            {
+                hr = E_MOREDATA;
+                *pcchOut = cchValue;
+            }
+        }
+    }
+    else
+    {
+        hr = E_INVALIDARG;
+    }
+
+    StrSecureZeroFreeString(sczValue);
+    return hr;
+}
+
+static HRESULT BAEngineEscapeString(
+    __in BOOTSTRAPPER_ENGINE_CONTEXT* /*pContext*/,
+    __in BAENGINE_ESCAPESTRING_ARGS* pArgs,
+    __in BAENGINE_ESCAPESTRING_RESULTS* pResults
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR sczValue = NULL;
+    size_t cchRemaining = 0;
+    LPCWSTR wzIn = pArgs->wzIn;
+    LPWSTR wzOut = pResults->wzOut;
+    DWORD* pcchOut = &pResults->cchOut;
+
+    if (wzIn && *wzIn)
+    {
+        hr = VariableEscapeString(wzIn, &sczValue);
+        if (SUCCEEDED(hr))
+        {
+            if (wzOut)
+            {
+                hr = ::StringCchCopyExW(wzOut, *pcchOut, sczValue, NULL, &cchRemaining, STRSAFE_FILL_BEHIND_NULL);
+                if (STRSAFE_E_INSUFFICIENT_BUFFER == hr)
+                {
+                    hr = E_MOREDATA;
+                    ::StringCchLengthW(sczValue, STRSAFE_MAX_CCH, &cchRemaining);
+                    *pcchOut = cchRemaining;
+                }
+            }
+            else
+            {
+                ::StringCchLengthW(sczValue, STRSAFE_MAX_CCH, &cchRemaining);
+                *pcchOut = cchRemaining;
+            }
+        }
+    }
+    else
+    {
+        hr = E_INVALIDARG;
+    }
+
+    StrSecureZeroFreeString(sczValue);
+    return hr;
+}
+
+static HRESULT BAEngineEvaluateCondition(
+    __in BOOTSTRAPPER_ENGINE_CONTEXT* pContext,
+    __in BAENGINE_EVALUATECONDITION_ARGS* pArgs,
+    __in BAENGINE_EVALUATECONDITION_RESULTS* pResults
+    )
+{
+    HRESULT hr = S_OK;
+    LPCWSTR wzCondition = pArgs->wzCondition;
+    BOOL* pf = &pResults->f;
+
+    if (wzCondition && *wzCondition)
+    {
+        hr = ConditionEvaluate(&pContext->pEngineState->variables, wzCondition, pf);
+    }
+    else
+    {
+        hr = E_INVALIDARG;
+    }
+
+    return hr;
+}
+
+static HRESULT BAEngineLog(
+    __in BOOTSTRAPPER_ENGINE_CONTEXT* /*pContext*/,
+    __in BAENGINE_LOG_ARGS* pArgs,
+    __in BAENGINE_LOG_RESULTS* /*pResults*/
+    )
+{
+    HRESULT hr = S_OK;
+    REPORT_LEVEL rl = REPORT_NONE;
+    BOOTSTRAPPER_LOG_LEVEL level = pArgs->level;
+    LPCWSTR wzMessage = pArgs->wzMessage;
+
+    switch (level)
+    {
+    case BOOTSTRAPPER_LOG_LEVEL_STANDARD:
+        rl = REPORT_STANDARD;
+        break;
+
+    case BOOTSTRAPPER_LOG_LEVEL_VERBOSE:
+        rl = REPORT_VERBOSE;
+        break;
+
+    case BOOTSTRAPPER_LOG_LEVEL_DEBUG:
+        rl = REPORT_DEBUG;
+        break;
+
+    case BOOTSTRAPPER_LOG_LEVEL_ERROR:
+        rl = REPORT_ERROR;
+        break;
+
+    default:
+        ExitFunction1(hr = E_INVALIDARG);
+    }
+
+    hr = LogStringLine(rl, "%ls", wzMessage);
+    ExitOnFailure(hr, "Failed to log BA message.");
+
+LExit:
+    return hr;
+}
+
+static HRESULT BAEngineSendEmbeddedError(
+    __in BOOTSTRAPPER_ENGINE_CONTEXT* pContext,
+    __in BAENGINE_SENDEMBEDDEDERROR_ARGS* pArgs,
+    __in BAENGINE_SENDEMBEDDEDERROR_RESULTS* pResults
+    )
+{
+    HRESULT hr = S_OK;
+    BYTE* pbData = NULL;
+    DWORD cbData = 0;
+    DWORD dwResult = 0;
+    DWORD dwErrorCode = pArgs->dwErrorCode;
+    LPCWSTR wzMessage = pArgs->wzMessage;
+    DWORD dwUIHint = pArgs->dwUIHint;
+    int* pnResult = &pResults->nResult;
+
+    if (BURN_MODE_EMBEDDED != pContext->pEngineState->mode)
+    {
+        hr = HRESULT_FROM_WIN32(ERROR_INVALID_STATE);
+        ExitOnRootFailure(hr, "BA requested to send embedded message when not in embedded mode.");
+    }
+
+    hr = BuffWriteNumber(&pbData, &cbData, dwErrorCode);
+    ExitOnFailure(hr, "Failed to write error code to message buffer.");
+
+    hr = BuffWriteString(&pbData, &cbData, wzMessage ? wzMessage : L"");
+    ExitOnFailure(hr, "Failed to write message string to message buffer.");
+
+    hr = BuffWriteNumber(&pbData, &cbData, dwUIHint);
+    ExitOnFailure(hr, "Failed to write UI hint to message buffer.");
+
+    hr = PipeSendMessage(pContext->pEngineState->embeddedConnection.hPipe, BURN_EMBEDDED_MESSAGE_TYPE_ERROR, pbData, cbData, NULL, NULL, &dwResult);
+    ExitOnFailure(hr, "Failed to send embedded message over pipe.");
+
+    *pnResult = static_cast<int>(dwResult);
+
+LExit:
+    ReleaseBuffer(pbData);
+    return hr;
+}
+
+static HRESULT BAEngineSendEmbeddedProgress(
+    __in BOOTSTRAPPER_ENGINE_CONTEXT* pContext,
+    __in BAENGINE_SENDEMBEDDEDPROGRESS_ARGS* pArgs,
+    __in BAENGINE_SENDEMBEDDEDPROGRESS_RESULTS* pResults
+    )
+{
+    HRESULT hr = S_OK;
+    BYTE* pbData = NULL;
+    DWORD cbData = 0;
+    DWORD dwResult = 0;
+    DWORD dwProgressPercentage = pArgs->dwProgressPercentage;
+    DWORD dwOverallProgressPercentage = pArgs->dwOverallProgressPercentage;
+    int* pnResult = &pResults->nResult;
+
+    if (BURN_MODE_EMBEDDED != pContext->pEngineState->mode)
+    {
+        hr = HRESULT_FROM_WIN32(ERROR_INVALID_STATE);
+        ExitOnRootFailure(hr, "BA requested to send embedded progress message when not in embedded mode.");
+    }
+
+    hr = BuffWriteNumber(&pbData, &cbData, dwProgressPercentage);
+    ExitOnFailure(hr, "Failed to write progress percentage to message buffer.");
+
+    hr = BuffWriteNumber(&pbData, &cbData, dwOverallProgressPercentage);
+    ExitOnFailure(hr, "Failed to write overall progress percentage to message buffer.");
+
+    hr = PipeSendMessage(pContext->pEngineState->embeddedConnection.hPipe, BURN_EMBEDDED_MESSAGE_TYPE_PROGRESS, pbData, cbData, NULL, NULL, &dwResult);
+    ExitOnFailure(hr, "Failed to send embedded progress message over pipe.");
+
+    *pnResult = static_cast<int>(dwResult);
+
+LExit:
+    ReleaseBuffer(pbData);
+    return hr;
+}
+
+static HRESULT BAEngineSetUpdate(
+    __in BOOTSTRAPPER_ENGINE_CONTEXT* pContext,
+    __in const BAENGINE_SETUPDATE_ARGS* pArgs,
+    __in BAENGINE_SETUPDATE_RESULTS* /*pResults*/
+    )
+{
+    HRESULT hr = S_OK;
+    LPCWSTR sczId = NULL;
+    LPWSTR sczLocalSource = NULL;
+    LPWSTR sczCommandline = NULL;
+    UUID guid = { };
+    WCHAR wzGuid[39];
+    RPC_STATUS rs = RPC_S_OK;
+    LPCWSTR wzLocalSource = pArgs->wzLocalSource;
+    LPCWSTR wzDownloadSource = pArgs->wzDownloadSource;
+    DWORD64 qwSize = pArgs->qwSize;
+    BOOTSTRAPPER_UPDATE_HASH_TYPE hashType = pArgs->hashType;
+    BYTE* rgbHash = pArgs->rgbHash;
+    DWORD cbHash = pArgs->cbHash;
+
+    ::EnterCriticalSection(&pContext->pEngineState->csActive);
+
+    if ((!wzLocalSource || !*wzLocalSource) && (!wzDownloadSource || !*wzDownloadSource))
+    {
+        UpdateUninitialize(&pContext->pEngineState->update);
+    }
+    else if (BOOTSTRAPPER_UPDATE_HASH_TYPE_NONE == hashType && (0 != cbHash || rgbHash))
+    {
+        hr = E_INVALIDARG;
+    }
+    else if (BOOTSTRAPPER_UPDATE_HASH_TYPE_SHA1 == hashType && (SHA1_HASH_LEN != cbHash || !rgbHash))
+    {
+        hr = E_INVALIDARG;
+    }
+    else
+    {
+        UpdateUninitialize(&pContext->pEngineState->update);
+
+        if (!wzLocalSource || !*wzLocalSource)
+        {
+            hr = StrAllocFormatted(&sczLocalSource, L"update\\%ls", pContext->pEngineState->registration.sczExecutableName);
+            ExitOnFailure(hr, "Failed to default local update source");
+        }
+
+        hr = CoreRecreateCommandLine(&sczCommandline, BOOTSTRAPPER_ACTION_INSTALL, pContext->pEngineState->command.display, pContext->pEngineState->command.restart, BOOTSTRAPPER_RELATION_NONE, FALSE, pContext->pEngineState->registration.sczActiveParent, pContext->pEngineState->registration.sczAncestors, NULL, pContext->pEngineState->command.wzCommandLine);
+        ExitOnFailure(hr, "Failed to recreate command-line for update bundle.");
+
+        // Per-user bundles would fail to use the downloaded update bundle, as the existing install would already be cached 
+        // at the registration id's location.  Here I am generating a random guid, but in the future it would be nice if the
+        // feed would provide the ID of the update.
+        if (!pContext->pEngineState->registration.fPerMachine)
+        {
+            rs = ::UuidCreate(&guid);
+            hr = HRESULT_FROM_RPC(rs);
+            ExitOnFailure(hr, "Failed to create bundle update guid.");
+
+            if (!::StringFromGUID2(guid, wzGuid, countof(wzGuid)))
+            {
+                hr = E_OUTOFMEMORY;
+                ExitOnRootFailure(hr, "Failed to convert bundle update guid into string.");
+            }
+
+            sczId = wzGuid;
+        }
+        else
+        {
+            sczId = pContext->pEngineState->registration.sczId;
+        }
+
+        hr = PseudoBundleInitialize(FILEMAKEVERSION(rmj, rmm, rup, 0), &pContext->pEngineState->update.package, FALSE, sczId, BOOTSTRAPPER_RELATION_UPDATE, BOOTSTRAPPER_PACKAGE_STATE_ABSENT, pContext->pEngineState->registration.sczExecutableName, sczLocalSource ? sczLocalSource : wzLocalSource, wzDownloadSource, qwSize, TRUE, sczCommandline, NULL, NULL, NULL, rgbHash, cbHash);
+        ExitOnFailure(hr, "Failed to set update bundle.");
+
+        pContext->pEngineState->update.fUpdateAvailable = TRUE;
+    }
+
+LExit:
+    ::LeaveCriticalSection(&pContext->pEngineState->csActive);
+
+    ReleaseStr(sczCommandline);
+    ReleaseStr(sczLocalSource);
+    return hr;
+}
+
+static HRESULT BAEngineSetLocalSource(
+    __in BOOTSTRAPPER_ENGINE_CONTEXT* pContext,
+    __in BAENGINE_SETLOCALSOURCE_ARGS* pArgs,
+    __in BAENGINE_SETLOCALSOURCE_RESULTS* /*pResults*/
+    )
+{
+    HRESULT hr = S_OK;
+    BURN_CONTAINER* pContainer = NULL;
+    BURN_PAYLOAD* pPayload = NULL;
+    LPCWSTR wzPackageOrContainerId = pArgs->wzPackageOrContainerId;
+    LPCWSTR wzPayloadId = pArgs->wzPayloadId;
+    LPCWSTR wzPath = pArgs->wzPath;
+
+    ::EnterCriticalSection(&pContext->pEngineState->csActive);
+    hr = UserExperienceEnsureEngineInactive(&pContext->pEngineState->userExperience);
+    ExitOnFailure(hr, "Engine is active, cannot change engine state.");
+
+    if (!wzPath || !*wzPath)
+    {
+        hr = E_INVALIDARG;
+    }
+    else if (wzPayloadId && * wzPayloadId)
+    {
+        hr = PayloadFindById(&pContext->pEngineState->payloads, wzPayloadId, &pPayload);
+        ExitOnFailure(hr, "BA requested unknown payload with id: %ls", wzPayloadId);
+
+        if (BURN_PAYLOAD_PACKAGING_EMBEDDED == pPayload->packaging)
+        {
+            hr = HRESULT_FROM_WIN32(ERROR_INVALID_OPERATION);
+            ExitOnFailure(hr, "BA denied while trying to set source on embedded payload: %ls", wzPayloadId);
+        }
+
+        hr = StrAllocString(&pPayload->sczSourcePath, wzPath, 0);
+        ExitOnFailure(hr, "Failed to set source path for payload.");
+    }
+    else if (wzPackageOrContainerId && *wzPackageOrContainerId)
+    {
+        hr = ContainerFindById(&pContext->pEngineState->containers, wzPackageOrContainerId, &pContainer);
+        ExitOnFailure(hr, "BA requested unknown container with id: %ls", wzPackageOrContainerId);
+
+        hr = StrAllocString(&pContainer->sczSourcePath, wzPath, 0);
+        ExitOnFailure(hr, "Failed to set source path for container.");
+    }
+    else
+    {
+        hr = E_INVALIDARG;
+    }
+
+LExit:
+    ::LeaveCriticalSection(&pContext->pEngineState->csActive);
+    return hr;
+}
+
+static HRESULT BAEngineSetDownloadSource(
+    __in BOOTSTRAPPER_ENGINE_CONTEXT* pContext,
+    __in BAENGINE_SETDOWNLOADSOURCE_ARGS* pArgs,
+    __in BAENGINE_SETDOWNLOADSOURCE_RESULTS* /*pResults*/
+    )
+{
+    HRESULT hr = S_OK;
+    BURN_CONTAINER* pContainer = NULL;
+    BURN_PAYLOAD* pPayload = NULL;
+    DOWNLOAD_SOURCE* pDownloadSource = NULL;
+    LPCWSTR wzPackageOrContainerId = pArgs->wzPackageOrContainerId;
+    LPCWSTR wzPayloadId = pArgs->wzPayloadId;
+    LPCWSTR wzUrl = pArgs->wzUrl;
+    LPCWSTR wzUser = pArgs->wzUser;
+    LPCWSTR wzPassword = pArgs->wzPassword;
+
+    ::EnterCriticalSection(&pContext->pEngineState->csActive);
+    hr = UserExperienceEnsureEngineInactive(&pContext->pEngineState->userExperience);
+    ExitOnFailure(hr, "Engine is active, cannot change engine state.");
+
+    if (wzPayloadId && *wzPayloadId)
+    {
+        hr = PayloadFindById(&pContext->pEngineState->payloads, wzPayloadId, &pPayload);
+        ExitOnFailure(hr, "BA requested unknown payload with id: %ls", wzPayloadId);
+
+        if (BURN_PAYLOAD_PACKAGING_EMBEDDED == pPayload->packaging)
+        {
+            hr = HRESULT_FROM_WIN32(ERROR_INVALID_OPERATION);
+            ExitOnFailure(hr, "BA denied while trying to set download URL on embedded payload: %ls", wzPayloadId);
+        }
+
+        pDownloadSource = &pPayload->downloadSource;
+    }
+    else if (wzPackageOrContainerId && *wzPackageOrContainerId)
+    {
+        hr = ContainerFindById(&pContext->pEngineState->containers, wzPackageOrContainerId, &pContainer);
+        ExitOnFailure(hr, "BA requested unknown container with id: %ls", wzPackageOrContainerId);
+
+        pDownloadSource = &pContainer->downloadSource;
+    }
+    else
+    {
+        hr = E_INVALIDARG;
+        ExitOnFailure(hr, "BA did not provide container or payload id.");
+    }
+
+    if (wzUrl && *wzUrl)
+    {
+        hr = StrAllocString(&pDownloadSource->sczUrl, wzUrl, 0);
+        ExitOnFailure(hr, "Failed to set download URL.");
+
+        if (wzUser && *wzUser)
+        {
+            hr = StrAllocString(&pDownloadSource->sczUser, wzUser, 0);
+            ExitOnFailure(hr, "Failed to set download user.");
+
+            if (wzPassword && *wzPassword)
+            {
+                hr = StrAllocString(&pDownloadSource->sczPassword, wzPassword, 0);
+                ExitOnFailure(hr, "Failed to set download password.");
+            }
+            else // no password.
+            {
+                ReleaseNullStr(pDownloadSource->sczPassword);
+            }
+        }
+        else // no user means no password either.
+        {
+            ReleaseNullStr(pDownloadSource->sczUser);
+            ReleaseNullStr(pDownloadSource->sczPassword);
+        }
+    }
+    else // no URL provided means clear out the whole download source.
+    {
+        ReleaseNullStr(pDownloadSource->sczUrl);
+        ReleaseNullStr(pDownloadSource->sczUser);
+        ReleaseNullStr(pDownloadSource->sczPassword);
+    }
+
+LExit:
+    ::LeaveCriticalSection(&pContext->pEngineState->csActive);
+    return hr;
+}
+
+static HRESULT BAEngineSetVariableNumeric(
+    __in BOOTSTRAPPER_ENGINE_CONTEXT* pContext,
+    __in const BAENGINE_SETVARIABLENUMERIC_ARGS* pArgs,
+    __in BAENGINE_SETVARIABLENUMERIC_RESULTS* /*pResults*/
+    )
+{
+    HRESULT hr = S_OK;
+    LPCWSTR wzVariable = pArgs->wzVariable;
+    LONGLONG llValue = pArgs->llValue;
+
+    if (wzVariable && *wzVariable)
+    {
+        hr = VariableSetNumeric(&pContext->pEngineState->variables, wzVariable, llValue, FALSE);
+        ExitOnFailure(hr, "Failed to set numeric variable.");
+    }
+    else
+    {
+        hr = E_INVALIDARG;
+        ExitOnFailure(hr, "BA did not provide variable name.");
+    }
+
+LExit:
+    return hr;
+}
+
+static HRESULT BAEngineSetVariableString(
+    __in BOOTSTRAPPER_ENGINE_CONTEXT* pContext,
+    __in const BAENGINE_SETVARIABLESTRING_ARGS* pArgs,
+    __in BAENGINE_SETVARIABLESTRING_RESULTS* /*pResults*/
+    )
+{
+    HRESULT hr = S_OK;
+    LPCWSTR wzVariable = pArgs->wzVariable;
+    LPCWSTR wzValue = pArgs->wzValue;
+
+    if (wzVariable && *wzVariable)
+    {
+        hr = VariableSetString(&pContext->pEngineState->variables, wzVariable, wzValue, FALSE);
+        ExitOnFailure(hr, "Failed to set numeric variable.");
+    }
+    else
+    {
+        hr = E_INVALIDARG;
+        ExitOnFailure(hr, "BA did not provide variable name.");
+    }
+
+LExit:
+    return hr;
+}
+
+static HRESULT BAEngineSetVariableVersion(
+    __in BOOTSTRAPPER_ENGINE_CONTEXT* pContext,
+    __in const BAENGINE_SETVARIABLEVERSION_ARGS* pArgs,
+    __in BAENGINE_SETVARIABLEVERSION_RESULTS* /*pResults*/
+    )
+{
+    HRESULT hr = S_OK;
+    LPCWSTR wzVariable = pArgs->wzVariable;
+    DWORD64 qwValue = pArgs->qwValue;
+
+    if (wzVariable && *wzVariable)
+    {
+        hr = VariableSetVersion(&pContext->pEngineState->variables, wzVariable, qwValue, FALSE);
+        ExitOnFailure(hr, "Failed to set version variable.");
+    }
+    else
+    {
+        hr = E_INVALIDARG;
+        ExitOnFailure(hr, "BA did not provide variable name.");
+    }
+
+LExit:
+    return hr;
+}
+
+static HRESULT BAEngineCloseSplashScreen(
+    __in BOOTSTRAPPER_ENGINE_CONTEXT* pContext,
+    __in const BAENGINE_CLOSESPLASHSCREEN_ARGS* /*pArgs*/,
+    __in BAENGINE_CLOSESPLASHSCREEN_RESULTS* /*pResults*/
+    )
+{
+    // If the splash screen is still around, close it.
+    if (::IsWindow(pContext->pEngineState->command.hwndSplashScreen))
+    {
+        ::PostMessageW(pContext->pEngineState->command.hwndSplashScreen, WM_CLOSE, 0, 0);
+    }
+
+    return S_OK;
+}
+
+static HRESULT BAEngineDetect(
+    __in BOOTSTRAPPER_ENGINE_CONTEXT* pContext,
+    __in BAENGINE_DETECT_ARGS* pArgs,
+    __in BAENGINE_DETECT_RESULTS* /*pResults*/
+    )
+{
+    HRESULT hr = S_OK;
+
+    if (!::PostThreadMessageW(pContext->dwThreadId, WM_BURN_DETECT, 0, reinterpret_cast<LPARAM>(pArgs->hwndParent)))
+    {
+        ExitWithLastError(hr, "Failed to post detect message.");
+    }
+
+LExit:
+    return hr;
+}
+
+static HRESULT BAEnginePlan(
+    __in BOOTSTRAPPER_ENGINE_CONTEXT* pContext,
+    __in const BAENGINE_PLAN_ARGS* pArgs,
+    __in BAENGINE_PLAN_RESULTS* /*pResults*/
+    )
+{
+    HRESULT hr = S_OK;
+    BOOTSTRAPPER_ACTION action = pArgs->action;
+
+    if (!::PostThreadMessageW(pContext->dwThreadId, WM_BURN_PLAN, 0, action))
+    {
+        ExitWithLastError(hr, "Failed to post plan message.");
+    }
+
+LExit:
+    return hr;
+}
+
+static HRESULT BAEngineElevate(
+    __in BOOTSTRAPPER_ENGINE_CONTEXT* pContext,
+    __in const BAENGINE_ELEVATE_ARGS* pArgs,
+    __in BAENGINE_ELEVATE_RESULTS* /*pResults*/
+    )
+{
+    HRESULT hr = S_OK;
+
+    if (INVALID_HANDLE_VALUE != pContext->pEngineState->companionConnection.hPipe)
+    {
+        hr = HRESULT_FROM_WIN32(ERROR_ALREADY_INITIALIZED);
+    }
+    else if (!::PostThreadMessageW(pContext->dwThreadId, WM_BURN_ELEVATE, 0, reinterpret_cast<LPARAM>(pArgs->hwndParent)))
+    {
+        ExitWithLastError(hr, "Failed to post elevate message.");
+    }
+
+LExit:
+    return hr;
+}
+
+static HRESULT BAEngineApply(
+    __in BOOTSTRAPPER_ENGINE_CONTEXT* pContext,
+    __in const BAENGINE_APPLY_ARGS* pArgs,
+    __in BAENGINE_APPLY_RESULTS* /*pResults*/
+    )
+{
+    HRESULT hr = S_OK;
+
+    if (!::PostThreadMessageW(pContext->dwThreadId, WM_BURN_APPLY, 0, reinterpret_cast<LPARAM>(pArgs->hwndParent)))
+    {
+        ExitWithLastError(hr, "Failed to post apply message.");
+    }
+
+LExit:
+    return hr;
+}
+
+static HRESULT BAEngineQuit(
+    __in BOOTSTRAPPER_ENGINE_CONTEXT* pContext,
+    __in const BAENGINE_QUIT_ARGS* pArgs,
+    __in BAENGINE_QUIT_RESULTS* /*pResults*/
+    )
+{
+    HRESULT hr = S_OK;
+
+    if (!::PostThreadMessageW(pContext->dwThreadId, WM_BURN_QUIT, static_cast<WPARAM>(pArgs->dwExitCode), 0))
+    {
+        ExitWithLastError(hr, "Failed to post shutdown message.");
+    }
+
+LExit:
+    return hr;
+}
+
+static HRESULT BAEngineLaunchApprovedExe(
+    __in BOOTSTRAPPER_ENGINE_CONTEXT* pContext,
+    __in const BAENGINE_LAUNCHAPPROVEDEXE_ARGS* pArgs,
+    __in BAENGINE_LAUNCHAPPROVEDEXE_RESULTS* /*pResults*/
+    )
+{
+    HRESULT hr = S_OK;
+    BURN_APPROVED_EXE* pApprovedExe = NULL;
+    BOOL fLeaveCriticalSection = FALSE;
+    BURN_LAUNCH_APPROVED_EXE* pLaunchApprovedExe = (BURN_LAUNCH_APPROVED_EXE*)MemAlloc(sizeof(BURN_LAUNCH_APPROVED_EXE), TRUE);
+    HWND hwndParent = pArgs->hwndParent;
+    LPCWSTR wzApprovedExeForElevationId = pArgs->wzApprovedExeForElevationId;
+    LPCWSTR wzArguments = pArgs->wzArguments;
+    DWORD dwWaitForInputIdleTimeout = pArgs->dwWaitForInputIdleTimeout;
+
+    ::EnterCriticalSection(&pContext->pEngineState->csActive);
+    fLeaveCriticalSection = TRUE;
+    hr = UserExperienceEnsureEngineInactive(&pContext->pEngineState->userExperience);
+    ExitOnFailure(hr, "Engine is active, cannot change engine state.");
+
+    if (!wzApprovedExeForElevationId || !*wzApprovedExeForElevationId)
+    {
+        ExitFunction1(hr = E_INVALIDARG);
+    }
+
+    hr = ApprovedExesFindById(&pContext->pEngineState->approvedExes, wzApprovedExeForElevationId, &pApprovedExe);
+    ExitOnFailure(hr, "BA requested unknown approved exe with id: %ls", wzApprovedExeForElevationId);
+
+    ::LeaveCriticalSection(&pContext->pEngineState->csActive);
+    fLeaveCriticalSection = FALSE;
+
+    hr = StrAllocString(&pLaunchApprovedExe->sczId, wzApprovedExeForElevationId, NULL);
+    ExitOnFailure(hr, "Failed to copy the id.");
+
+    if (wzArguments)
+    {
+        hr = StrAllocString(&pLaunchApprovedExe->sczArguments, wzArguments, NULL);
+        ExitOnFailure(hr, "Failed to copy the arguments.");
+    }
+
+    pLaunchApprovedExe->dwWaitForInputIdleTimeout = dwWaitForInputIdleTimeout;
+
+    pLaunchApprovedExe->hwndParent = hwndParent;
+
+    if (!::PostThreadMessageW(pContext->dwThreadId, WM_BURN_LAUNCH_APPROVED_EXE, 0, reinterpret_cast<LPARAM>(pLaunchApprovedExe)))
+    {
+        ExitWithLastError(hr, "Failed to post launch approved exe message.");
+    }
+
+LExit:
+    if (fLeaveCriticalSection)
+    {
+        ::LeaveCriticalSection(&pContext->pEngineState->csActive);
+    }
+
+    if (FAILED(hr))
+    {
+        ApprovedExesUninitializeLaunch(pLaunchApprovedExe);
+    }
+
+    return hr;
+}
+
+HRESULT WINAPI EngineForApplicationProc(
+    __in BOOTSTRAPPER_ENGINE_MESSAGE message,
+    __in const LPVOID pvArgs,
+    __inout LPVOID pvResults,
+    __in_opt LPVOID pvContext
+    )
+{
+    HRESULT hr = S_OK;
+    BOOTSTRAPPER_ENGINE_CONTEXT* pContext = reinterpret_cast<BOOTSTRAPPER_ENGINE_CONTEXT*>(pvContext);
+
+    if (!pContext || !pvArgs || !pvResults)
+    {
+        ExitFunction1(hr = E_INVALIDARG);
+    }
+
+    switch (message)
+    {
+    case BOOTSTRAPPER_ENGINE_MESSAGE_GETPACKAGECOUNT:
+        hr = BAEngineGetPackageCount(pContext, reinterpret_cast<BAENGINE_GETPACKAGECOUNT_ARGS*>(pvArgs), reinterpret_cast<BAENGINE_GETPACKAGECOUNT_RESULTS*>(pvResults));
+        break;
+    case BOOTSTRAPPER_ENGINE_MESSAGE_GETVARIABLENUMERIC:
+        hr = BAEngineGetVariableNumeric(pContext, reinterpret_cast<BAENGINE_GETVARIABLENUMERIC_ARGS*>(pvArgs), reinterpret_cast<BAENGINE_GETVARIABLENUMERIC_RESULTS*>(pvResults));
+        break;
+    case BOOTSTRAPPER_ENGINE_MESSAGE_GETVARIABLESTRING:
+        hr = BAEngineGetVariableString(pContext, reinterpret_cast<BAENGINE_GETVARIABLESTRING_ARGS*>(pvArgs), reinterpret_cast<BAENGINE_GETVARIABLESTRING_RESULTS*>(pvResults));
+        break;
+    case BOOTSTRAPPER_ENGINE_MESSAGE_GETVARIABLEVERSION:
+        hr = BAEngineGetVariableVersion(pContext, reinterpret_cast<BAENGINE_GETVARIABLEVERSION_ARGS*>(pvArgs), reinterpret_cast<BAENGINE_GETVARIABLEVERSION_RESULTS*>(pvResults));
+        break;
+    case BOOTSTRAPPER_ENGINE_MESSAGE_FORMATSTRING:
+        hr = BAEngineFormatString(pContext, reinterpret_cast<BAENGINE_FORMATSTRING_ARGS*>(pvArgs), reinterpret_cast<BAENGINE_FORMATSTRING_RESULTS*>(pvResults));
+        break;
+    case BOOTSTRAPPER_ENGINE_MESSAGE_ESCAPESTRING:
+        hr = BAEngineEscapeString(pContext, reinterpret_cast<BAENGINE_ESCAPESTRING_ARGS*>(pvArgs), reinterpret_cast<BAENGINE_ESCAPESTRING_RESULTS*>(pvResults));
+        break;
+    case BOOTSTRAPPER_ENGINE_MESSAGE_EVALUATECONDITION:
+        hr = BAEngineEvaluateCondition(pContext, reinterpret_cast<BAENGINE_EVALUATECONDITION_ARGS*>(pvArgs), reinterpret_cast<BAENGINE_EVALUATECONDITION_RESULTS*>(pvResults));
+        break;
+    case BOOTSTRAPPER_ENGINE_MESSAGE_LOG:
+        hr = BAEngineLog(pContext, reinterpret_cast<BAENGINE_LOG_ARGS*>(pvArgs), reinterpret_cast<BAENGINE_LOG_RESULTS*>(pvResults));
+        break;
+    case BOOTSTRAPPER_ENGINE_MESSAGE_SENDEMBEDDEDERROR:
+        hr = BAEngineSendEmbeddedError(pContext, reinterpret_cast<BAENGINE_SENDEMBEDDEDERROR_ARGS*>(pvArgs), reinterpret_cast<BAENGINE_SENDEMBEDDEDERROR_RESULTS*>(pvResults));
+        break;
+    case BOOTSTRAPPER_ENGINE_MESSAGE_SENDEMBEDDEDPROGRESS:
+        hr = BAEngineSendEmbeddedProgress(pContext, reinterpret_cast<BAENGINE_SENDEMBEDDEDPROGRESS_ARGS*>(pvArgs), reinterpret_cast<BAENGINE_SENDEMBEDDEDPROGRESS_RESULTS*>(pvResults));
+        break;
+    case BOOTSTRAPPER_ENGINE_MESSAGE_SETUPDATE:
+        hr = BAEngineSetUpdate(pContext, reinterpret_cast<BAENGINE_SETUPDATE_ARGS*>(pvArgs), reinterpret_cast<BAENGINE_SETUPDATE_RESULTS*>(pvResults));
+        break;
+    case BOOTSTRAPPER_ENGINE_MESSAGE_SETLOCALSOURCE:
+        hr = BAEngineSetLocalSource(pContext, reinterpret_cast<BAENGINE_SETLOCALSOURCE_ARGS*>(pvArgs), reinterpret_cast<BAENGINE_SETLOCALSOURCE_RESULTS*>(pvResults));
+        break;
+    case BOOTSTRAPPER_ENGINE_MESSAGE_SETDOWNLOADSOURCE:
+        hr = BAEngineSetDownloadSource(pContext, reinterpret_cast<BAENGINE_SETDOWNLOADSOURCE_ARGS*>(pvArgs), reinterpret_cast<BAENGINE_SETDOWNLOADSOURCE_RESULTS*>(pvResults));
+        break;
+    case BOOTSTRAPPER_ENGINE_MESSAGE_SETVARIABLENUMERIC:
+        hr = BAEngineSetVariableNumeric(pContext, reinterpret_cast<BAENGINE_SETVARIABLENUMERIC_ARGS*>(pvArgs), reinterpret_cast<BAENGINE_SETVARIABLENUMERIC_RESULTS*>(pvResults));
+        break;
+    case BOOTSTRAPPER_ENGINE_MESSAGE_SETVARIABLESTRING:
+        hr = BAEngineSetVariableString(pContext, reinterpret_cast<BAENGINE_SETVARIABLESTRING_ARGS*>(pvArgs), reinterpret_cast<BAENGINE_SETVARIABLESTRING_RESULTS*>(pvResults));
+        break;
+    case BOOTSTRAPPER_ENGINE_MESSAGE_SETVARIABLEVERSION:
+        hr = BAEngineSetVariableVersion(pContext, reinterpret_cast<BAENGINE_SETVARIABLEVERSION_ARGS*>(pvArgs), reinterpret_cast<BAENGINE_SETVARIABLEVERSION_RESULTS*>(pvResults));
+        break;
+    case BOOTSTRAPPER_ENGINE_MESSAGE_CLOSESPLASHSCREEN:
+        hr = BAEngineCloseSplashScreen(pContext, reinterpret_cast<BAENGINE_CLOSESPLASHSCREEN_ARGS*>(pvArgs), reinterpret_cast<BAENGINE_CLOSESPLASHSCREEN_RESULTS*>(pvResults));
+        break;
+    case BOOTSTRAPPER_ENGINE_MESSAGE_DETECT:
+        hr = BAEngineDetect(pContext, reinterpret_cast<BAENGINE_DETECT_ARGS*>(pvArgs), reinterpret_cast<BAENGINE_DETECT_RESULTS*>(pvResults));
+        break;
+    case BOOTSTRAPPER_ENGINE_MESSAGE_PLAN:
+        hr = BAEnginePlan(pContext, reinterpret_cast<BAENGINE_PLAN_ARGS*>(pvArgs), reinterpret_cast<BAENGINE_PLAN_RESULTS*>(pvResults));
+        break;
+    case BOOTSTRAPPER_ENGINE_MESSAGE_ELEVATE:
+        hr = BAEngineElevate(pContext, reinterpret_cast<BAENGINE_ELEVATE_ARGS*>(pvArgs), reinterpret_cast<BAENGINE_ELEVATE_RESULTS*>(pvResults));
+        break;
+    case BOOTSTRAPPER_ENGINE_MESSAGE_APPLY:
+        hr = BAEngineApply(pContext, reinterpret_cast<BAENGINE_APPLY_ARGS*>(pvArgs), reinterpret_cast<BAENGINE_APPLY_RESULTS*>(pvResults));
+        break;
+    case BOOTSTRAPPER_ENGINE_MESSAGE_QUIT:
+        hr = BAEngineQuit(pContext, reinterpret_cast<BAENGINE_QUIT_ARGS*>(pvArgs), reinterpret_cast<BAENGINE_QUIT_RESULTS*>(pvResults));
+        break;
+    case BOOTSTRAPPER_ENGINE_MESSAGE_LAUNCHAPPROVEDEXE:
+        hr = BAEngineLaunchApprovedExe(pContext, reinterpret_cast<BAENGINE_LAUNCHAPPROVEDEXE_ARGS*>(pvArgs), reinterpret_cast<BAENGINE_LAUNCHAPPROVEDEXE_RESULTS*>(pvResults));
+        break;
+    default:
+        hr = E_NOTIMPL;
+        break;
+    }
+
+LExit:
+    return hr;
+}
diff --git a/src/engine/EngineForApplication.h b/src/engine/EngineForApplication.h
new file mode 100644
index 00000000..1b755acc
--- /dev/null
+++ b/src/engine/EngineForApplication.h
@@ -0,0 +1,44 @@
+#pragma once
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+// constants
+
+enum WM_BURN
+{
+    WM_BURN_FIRST = WM_APP + 0xFFF, // this enum value must always be first.
+
+    WM_BURN_DETECT,
+    WM_BURN_PLAN,
+    WM_BURN_ELEVATE,
+    WM_BURN_APPLY,
+    WM_BURN_LAUNCH_APPROVED_EXE,
+    WM_BURN_QUIT,
+
+    WM_BURN_LAST, // this enum value must always be last.
+};
+
+// structs
+
+struct BOOTSTRAPPER_ENGINE_CONTEXT
+{
+    BURN_ENGINE_STATE* pEngineState;
+    DWORD dwThreadId;
+};
+
+// function declarations
+
+HRESULT WINAPI EngineForApplicationProc(
+    __in BOOTSTRAPPER_ENGINE_MESSAGE message,
+    __in const LPVOID pvArgs,
+    __inout LPVOID pvResults,
+    __in_opt LPVOID pvContext
+    );
+
+#if defined(__cplusplus)
+}
+#endif
diff --git a/src/engine/apply.cpp b/src/engine/apply.cpp
new file mode 100644
index 00000000..0cef9ac8
--- /dev/null
+++ b/src/engine/apply.cpp
@@ -0,0 +1,2516 @@
+// 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.
+
+#include "precomp.h"
+
+
+const DWORD BURN_CACHE_MAX_RECOMMENDED_VERIFY_TRYAGAIN_ATTEMPTS = 2;
+
+// structs
+
+struct BURN_CACHE_ACQUIRE_PROGRESS_CONTEXT
+{
+    BURN_USER_EXPERIENCE* pUX;
+    BURN_CONTAINER* pContainer;
+    BURN_PACKAGE* pPackage;
+    BURN_PAYLOAD* pPayload;
+    DWORD64 qwCacheProgress;
+    DWORD64 qwTotalCacheSize;
+
+    BOOL fCancel;
+    BOOL fError;
+};
+
+typedef struct _BURN_EXECUTE_CONTEXT
+{
+    BURN_USER_EXPERIENCE* pUX;
+    BOOL fRollback;
+    BURN_PACKAGE* pExecutingPackage;
+    DWORD cExecutedPackages;
+    DWORD cExecutePackagesTotal;
+    DWORD* pcOverallProgressTicks;
+} BURN_EXECUTE_CONTEXT;
+
+
+// internal function declarations
+static HRESULT WINAPI AuthenticationRequired(
+    __in LPVOID pData,
+    __in HINTERNET hUrl,
+    __in long lHttpCode,
+    __out BOOL* pfRetrySend,
+    __out BOOL* pfRetry
+    );
+
+static HRESULT ExecuteDependentRegistrationActions(
+    __in HANDLE hPipe,
+    __in const BURN_REGISTRATION* pRegistration,
+    __in_ecount(cActions) const BURN_DEPENDENT_REGISTRATION_ACTION* rgActions,
+    __in DWORD cActions
+    );
+static HRESULT ExtractContainer(
+    __in HANDLE hSourceEngineFile,
+    __in BURN_CONTAINER* pContainer,
+    __in_z LPCWSTR wzContainerPath,
+    __in_ecount(cExtractPayloads) BURN_EXTRACT_PAYLOAD* rgExtractPayloads,
+    __in DWORD cExtractPayloads
+    );
+static void UpdateCacheSuccessProgress(
+    __in BURN_PLAN* pPlan,
+    __in BURN_CACHE_ACTION* pCacheAction,
+    __inout DWORD64* pqwSuccessfulCachedProgress
+    );
+static HRESULT LayoutBundle(
+    __in BURN_USER_EXPERIENCE* pUX,
+    __in BURN_VARIABLES* pVariables,
+    __in HANDLE hPipe,
+    __in_z LPCWSTR wzExecutableName,
+    __in_z LPCWSTR wzLayoutDirectory,
+    __in_z LPCWSTR wzUnverifiedPath,
+    __in DWORD64 qwSuccessfulCacheProgress,
+    __in DWORD64 qwTotalCacheSize
+    );
+static HRESULT AcquireContainerOrPayload(
+    __in BURN_USER_EXPERIENCE* pUX,
+    __in BURN_VARIABLES* pVariables,
+    __in_opt BURN_CONTAINER* pContainer,
+    __in_opt BURN_PACKAGE* pPackage,
+    __in_opt BURN_PAYLOAD* pPayload,
+    __in LPCWSTR wzDestinationPath,
+    __in DWORD64 qwSuccessfulCacheProgress,
+    __in DWORD64 qwTotalCacheSize
+    );
+static HRESULT LayoutOrCacheContainerOrPayload(
+    __in BURN_USER_EXPERIENCE* pUX,
+    __in HANDLE hPipe,
+    __in_opt BURN_CONTAINER* pContainer,
+    __in_opt BURN_PACKAGE* pPackage,
+    __in_opt BURN_PAYLOAD* pPayload,
+    __in BOOL fAlreadyProvidedProgress,
+    __in DWORD64 qwSuccessfullyCacheProgress,
+    __in DWORD64 qwTotalCacheSize,
+    __in_z_opt LPCWSTR wzLayoutDirectory,
+    __in_z LPCWSTR wzUnverifiedPath,
+    __in BOOL fMove,
+    __in DWORD cTryAgainAttempts,
+    __out BOOL* pfRetry
+    );
+static HRESULT PromptForSource(
+    __in BURN_USER_EXPERIENCE* pUX,
+    __in_z LPCWSTR wzPackageOrContainerId,
+    __in_z_opt LPCWSTR wzPayloadId,
+    __in_z LPCWSTR wzLocalSource,
+    __in_z_opt LPCWSTR wzDownloadSource,
+    __out BOOL* pfRetry,
+    __out BOOL* pfDownload
+    );
+static HRESULT CopyPayload(
+    __in BURN_CACHE_ACQUIRE_PROGRESS_CONTEXT* pProgress,
+    __in_z LPCWSTR wzSourcePath,
+    __in_z LPCWSTR wzDestinationPath
+    );
+static HRESULT DownloadPayload(
+    __in BURN_CACHE_ACQUIRE_PROGRESS_CONTEXT* pProgress,
+    __in_z LPCWSTR wzDestinationPath
+    );
+static DWORD CALLBACK CacheProgressRoutine(
+    __in LARGE_INTEGER TotalFileSize,
+    __in LARGE_INTEGER TotalBytesTransferred,
+    __in LARGE_INTEGER StreamSize,
+    __in LARGE_INTEGER StreamBytesTransferred,
+    __in DWORD dwStreamNumber,
+    __in DWORD dwCallbackReason,
+    __in HANDLE hSourceFile,
+    __in HANDLE hDestinationFile,
+    __in_opt LPVOID lpData
+    );
+static void DoRollbackCache(
+    __in BURN_USER_EXPERIENCE* pUX,
+    __in BURN_PLAN* pPlan,
+    __in HANDLE hPipe,
+    __in DWORD dwCheckpoint
+    );
+static HRESULT DoExecuteAction(
+    __in BURN_ENGINE_STATE* pEngineState,
+    __in BURN_EXECUTE_ACTION* pExecuteAction,
+    __in_opt HANDLE hCacheThread,
+    __in BURN_EXECUTE_CONTEXT* pContext,
+    __inout BURN_ROLLBACK_BOUNDARY** ppRollbackBoundary,
+    __out DWORD* pdwCheckpoint,
+    __out BOOL* pfKeepRegistration,
+    __out BOOL* pfSuspend,
+    __out BOOTSTRAPPER_APPLY_RESTART* pRestart
+    );
+static HRESULT DoRollbackActions(
+    __in BURN_ENGINE_STATE* pEngineState,
+    __in BURN_EXECUTE_CONTEXT* pContext,
+    __in DWORD dwCheckpoint,
+    __in BOOL fInTransaction,
+    __out BOOL* pfKeepRegistration,
+    __out BOOTSTRAPPER_APPLY_RESTART* pRestart
+    );
+static HRESULT ExecuteExePackage(
+    __in BURN_ENGINE_STATE* pEngineState,
+    __in BURN_EXECUTE_ACTION* pExecuteAction,
+    __in BURN_EXECUTE_CONTEXT* pContext,
+    __in BOOL fRollback,
+    __out BOOL* pfRetry,
+    __out BOOL* pfSuspend,
+    __out BOOTSTRAPPER_APPLY_RESTART* pRestart
+    );
+static HRESULT ExecuteMsiPackage(
+    __in BURN_ENGINE_STATE* pEngineState,
+    __in BURN_EXECUTE_ACTION* pExecuteAction,
+    __in BURN_EXECUTE_CONTEXT* pContext,
+    __in BOOL fRollback,
+    __out BOOL* pfRetry,
+    __out BOOL* pfSuspend,
+    __out BOOTSTRAPPER_APPLY_RESTART* pRestart
+    );
+static HRESULT ExecuteMspPackage(
+    __in BURN_ENGINE_STATE* pEngineState,
+    __in BURN_EXECUTE_ACTION* pExecuteAction,
+    __in BURN_EXECUTE_CONTEXT* pContext,
+    __in BOOL fRollback,
+    __out BOOL* pfRetry,
+    __out BOOL* pfSuspend,
+    __out BOOTSTRAPPER_APPLY_RESTART* pRestart
+    );
+static HRESULT ExecuteMsuPackage(
+    __in BURN_ENGINE_STATE* pEngineState,
+    __in BURN_EXECUTE_ACTION* pExecuteAction,
+    __in BURN_EXECUTE_CONTEXT* pContext,
+    __in BOOL fRollback,
+    __in BOOL fStopWusaService,
+    __out BOOL* pfRetry,
+    __out BOOL* pfSuspend,
+    __out BOOTSTRAPPER_APPLY_RESTART* pRestart
+    );
+static HRESULT ExecutePackageProviderAction(
+    __in BURN_ENGINE_STATE* pEngineState,
+    __in BURN_EXECUTE_ACTION* pAction,
+    __in BURN_EXECUTE_CONTEXT* pContext
+    );
+static HRESULT ExecuteDependencyAction(
+    __in BURN_ENGINE_STATE* pEngineState,
+    __in BURN_EXECUTE_ACTION* pAction,
+    __in BURN_EXECUTE_CONTEXT* pContext
+    );
+static HRESULT ExecuteCompatiblePackageAction(
+    __in BURN_ENGINE_STATE* pEngineState,
+    __in BURN_EXECUTE_ACTION* pAction
+    );
+static HRESULT CleanPackage(
+    __in HANDLE hElevatedPipe,
+    __in BURN_PACKAGE* pPackage
+    );
+static int GenericExecuteMessageHandler(
+    __in GENERIC_EXECUTE_MESSAGE* pMessage,
+    __in LPVOID pvContext
+    );
+static int MsiExecuteMessageHandler(
+    __in WIU_MSI_EXECUTE_MESSAGE* pMessage,
+    __in_opt LPVOID pvContext
+    );
+static HRESULT ReportOverallProgressTicks(
+    __in BURN_USER_EXPERIENCE* pUX,
+    __in BOOL fRollback,
+    __in DWORD cOverallProgressTicksTotal,
+    __in DWORD cOverallProgressTicks
+    );
+static HRESULT ExecutePackageComplete(
+    __in BURN_USER_EXPERIENCE* pUX,
+    __in BURN_VARIABLES* pVariables,
+    __in BURN_PACKAGE* pPackage,
+    __in HRESULT hrOverall,
+    __in HRESULT hrExecute,
+    __in BOOL fRollback,
+    __out BOOTSTRAPPER_APPLY_RESTART* pRestart,
+    __out BOOL* pfRetry,
+    __out BOOL* pfSuspend
+    );
+
+static HRESULT DoMsiBeginTransaction(
+    __in BURN_EXECUTE_CONTEXT *context
+    , __in BURN_ENGINE_STATE* pEngineState
+);
+static HRESULT DoMsiCommitTransaction(
+    __in BURN_EXECUTE_CONTEXT *context
+    , __in BURN_ENGINE_STATE* pEngineState
+);
+static HRESULT DoMsiRollbackTransaction(
+    __in BURN_EXECUTE_CONTEXT *context
+    , __in BURN_ENGINE_STATE* pEngineState
+);
+static HRESULT ExecuteMsiBeginTransaction(
+    __in BURN_EXECUTE_CONTEXT* pContext
+    , __in BURN_ENGINE_STATE* pEngineState
+);
+static HRESULT ExecuteMsiCommitTransaction(
+    __in BURN_EXECUTE_CONTEXT* pContext
+    , __in BURN_ENGINE_STATE* pEngineState
+);
+static HRESULT ExecuteMsiRollbackTransaction(
+    __in BURN_EXECUTE_CONTEXT* pContext
+    , __in BURN_ENGINE_STATE* pEngineState
+);
+
+// function definitions
+
+extern "C" void ApplyInitialize()
+{
+    // Prevent the system from sleeping.
+    ::SetThreadExecutionState(ES_CONTINUOUS | ES_SYSTEM_REQUIRED);
+}
+
+extern "C" void ApplyUninitialize()
+{
+    ::SetThreadExecutionState(ES_CONTINUOUS);
+}
+
+extern "C" HRESULT ApplySetVariables(
+    __in BURN_VARIABLES* pVariables
+    )
+{
+    HRESULT hr = S_OK;
+
+    hr = VariableSetString(pVariables, BURN_BUNDLE_FORCED_RESTART_PACKAGE, NULL, TRUE);
+    ExitOnFailure(hr, "Failed to set the bundle forced restart package built-in variable.");
+
+LExit:
+    return hr;
+}
+
+extern "C" void ApplyReset(
+    __in BURN_USER_EXPERIENCE* pUX,
+    __in BURN_PACKAGES* pPackages
+    )
+{
+    UserExperienceExecuteReset(pUX);
+
+    for (DWORD i = 0; i < pPackages->cPackages; ++i)
+    {
+        BURN_PACKAGE* pPackage = pPackages->rgPackages + i;
+        pPackage->hrCacheResult = S_OK;
+    }
+}
+
+extern "C" HRESULT ApplyLock(
+    __in BOOL /*fPerMachine*/,
+    __out HANDLE* /*phLock*/
+    )
+{
+    HRESULT hr = S_OK;
+#if 0 // eventually figure out the correct way to support this. In its current form, embedded bundles (including related bundles) are hosed.
+    DWORD er = ERROR_SUCCESS;
+    HANDLE hLock = NULL;
+
+    hLock = ::CreateMutexW(NULL, TRUE, fPerMachine ? L"Global\\WixBurnExecutionLock" : L"Local\\WixBurnExecutionLock");
+    ExitOnNullWithLastError(hLock, hr, "Failed to create lock.");
+
+    er = ::GetLastError();
+    if (ERROR_ALREADY_EXISTS == er)
+    {
+        ExitFunction1(hr = HRESULT_FROM_WIN32(ERROR_INSTALL_ALREADY_RUNNING));
+    }
+
+    *phLock = hLock;
+    hLock = NULL;
+
+LExit:
+    ReleaseHandle(hLock);
+#endif
+    return hr;
+}
+
+extern "C" HRESULT ApplyRegister(
+    __in BURN_ENGINE_STATE* pEngineState
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR sczEngineWorkingPath = NULL;
+
+    hr = UserExperienceOnRegisterBegin(&pEngineState->userExperience);
+    ExitOnRootFailure(hr, "BA aborted register begin.");
+
+    // If we have a resume mode that suggests the bundle is on the machine.
+    if (BOOTSTRAPPER_RESUME_TYPE_REBOOT_PENDING < pEngineState->command.resumeType)
+    {
+        // resume previous session
+        if (pEngineState->registration.fPerMachine)
+        {
+            hr = ElevationSessionResume(pEngineState->companionConnection.hPipe, pEngineState->registration.sczResumeCommandLine, pEngineState->registration.fDisableResume, &pEngineState->variables);
+            ExitOnFailure(hr, "Failed to resume registration session in per-machine process.");
+        }
+        else
+        {
+            hr = RegistrationSessionResume(&pEngineState->registration, &pEngineState->variables);
+            ExitOnFailure(hr, "Failed to resume registration session.");
+        }
+    }
+    else // need to complete registration on the machine.
+    {
+        hr = CacheCalculateBundleWorkingPath(pEngineState->registration.sczId, pEngineState->registration.sczExecutableName, &sczEngineWorkingPath);
+        ExitOnFailure(hr, "Failed to calculate working path for engine.");
+
+        // begin new session
+        if (pEngineState->registration.fPerMachine)
+        {
+            hr = ElevationSessionBegin(pEngineState->companionConnection.hPipe, sczEngineWorkingPath, pEngineState->registration.sczResumeCommandLine, pEngineState->registration.fDisableResume, &pEngineState->variables, pEngineState->plan.dwRegistrationOperations, pEngineState->plan.dependencyRegistrationAction, pEngineState->plan.qwEstimatedSize);
+            ExitOnFailure(hr, "Failed to begin registration session in per-machine process.");
+        }
+        else
+        {
+            hr = RegistrationSessionBegin(sczEngineWorkingPath, &pEngineState->registration, &pEngineState->variables, &pEngineState->userExperience, pEngineState->plan.dwRegistrationOperations, pEngineState->plan.dependencyRegistrationAction, pEngineState->plan.qwEstimatedSize);
+            ExitOnFailure(hr, "Failed to begin registration session.");
+        }
+    }
+
+    // Apply any registration actions.
+    HRESULT hrExecuteRegistration = ExecuteDependentRegistrationActions(pEngineState->companionConnection.hPipe, &pEngineState->registration, pEngineState->plan.rgRegistrationActions, pEngineState->plan.cRegistrationActions);
+    UNREFERENCED_PARAMETER(hrExecuteRegistration);
+
+    // Try to save engine state.
+    hr = CoreSaveEngineState(pEngineState);
+    if (FAILED(hr))
+    {
+        LogErrorId(hr, MSG_STATE_NOT_SAVED, NULL, NULL, NULL);
+        hr = S_OK;
+    }
+
+LExit:
+    UserExperienceOnRegisterComplete(&pEngineState->userExperience, hr);
+    ReleaseStr(sczEngineWorkingPath);
+
+    return hr;
+}
+
+extern "C" HRESULT ApplyUnregister(
+    __in BURN_ENGINE_STATE* pEngineState,
+    __in BOOL fFailedOrRollback,
+    __in BOOL fKeepRegistration,
+    __in BOOL fSuspend,
+    __in BOOTSTRAPPER_APPLY_RESTART restart
+    )
+{
+    HRESULT hr = S_OK;
+    BURN_RESUME_MODE resumeMode = BURN_RESUME_MODE_NONE;
+
+    hr = UserExperienceOnUnregisterBegin(&pEngineState->userExperience);
+    ExitOnRootFailure(hr, "BA aborted unregister begin.");
+
+    // Calculate the correct resume mode. If a restart has been initiated, that trumps all other
+    // modes. If the user chose to suspend the install then we'll use that as the resume mode.
+    // Barring those special cases, if it was determined that we should keep the registration then
+    // do that, otherwise the resume mode was initialized to none and registration will be removed.
+    if (BOOTSTRAPPER_APPLY_RESTART_INITIATED == restart)
+    {
+        resumeMode = BURN_RESUME_MODE_REBOOT_PENDING;
+    }
+    else if (fSuspend)
+    {
+        resumeMode = BURN_RESUME_MODE_SUSPEND;
+    }
+    else if (fKeepRegistration)
+    {
+        resumeMode = BURN_RESUME_MODE_ARP;
+    }
+
+    // If apply failed in any way and we're going to be keeping the bundle registered then
+    // execute any rollback dependency registration actions.
+    if (fFailedOrRollback && fKeepRegistration)
+    {
+        // Execute any rollback registration actions.
+        HRESULT hrRegistrationRollback = ExecuteDependentRegistrationActions(pEngineState->companionConnection.hPipe, &pEngineState->registration, pEngineState->plan.rgRollbackRegistrationActions, pEngineState->plan.cRollbackRegistrationActions);
+        UNREFERENCED_PARAMETER(hrRegistrationRollback);
+    }
+
+    if (pEngineState->registration.fPerMachine)
+    {
+        hr = ElevationSessionEnd(pEngineState->companionConnection.hPipe, resumeMode, restart, pEngineState->plan.dependencyRegistrationAction);
+        ExitOnFailure(hr, "Failed to end session in per-machine process.");
+    }
+    else
+    {
+        hr = RegistrationSessionEnd(&pEngineState->registration, resumeMode, restart, pEngineState->plan.dependencyRegistrationAction);
+        ExitOnFailure(hr, "Failed to end session in per-user process.");
+    }
+
+    pEngineState->resumeMode = resumeMode;
+
+LExit:
+    UserExperienceOnUnregisterComplete(&pEngineState->userExperience, hr);
+
+    return hr;
+}
+
+extern "C" HRESULT ApplyCache(
+    __in HANDLE hSourceEngineFile,
+    __in BURN_USER_EXPERIENCE* pUX,
+    __in BURN_VARIABLES* pVariables,
+    __in BURN_PLAN* pPlan,
+    __in HANDLE hPipe,
+    __inout DWORD* pcOverallProgressTicks,
+    __out BOOL* pfRollback
+    )
+{
+    HRESULT hr = S_OK;
+    DWORD dwCheckpoint = 0;
+    BOOL fRetry = FALSE;
+    DWORD iRetryAction = BURN_PLAN_INVALID_ACTION_INDEX;
+    BURN_PACKAGE* pStartedPackage = NULL;
+    DWORD64 qwSuccessfulCachedProgress = 0;
+
+    // Allow us to retry and skip packages.
+    DWORD iPackageStartAction = BURN_PLAN_INVALID_ACTION_INDEX;
+    DWORD iPackageCompleteAction = BURN_PLAN_INVALID_ACTION_INDEX;
+
+    hr = UserExperienceOnCacheBegin(pUX);
+    ExitOnRootFailure(hr, "BA aborted cache.");
+
+    do
+    {
+        hr = S_OK;
+        fRetry = FALSE;
+
+        // Allow us to retry just a container or payload.
+        LPCWSTR wzRetryId = NULL;
+        DWORD iRetryContainerOrPayloadAction = BURN_PLAN_INVALID_ACTION_INDEX;
+        BOOTSTRAPPER_CACHEPACKAGECOMPLETE_ACTION cachePackageCompleteAction = BOOTSTRAPPER_CACHEPACKAGECOMPLETE_ACTION_NONE;
+
+        // cache actions
+        for (DWORD i = (BURN_PLAN_INVALID_ACTION_INDEX == iRetryAction) ? 0 : iRetryAction; SUCCEEDED(hr) && i < pPlan->cCacheActions; ++i)
+        {
+            BURN_CACHE_ACTION* pCacheAction = pPlan->rgCacheActions + i;
+            BOOL fRetryContainerOrPayload = FALSE;
+            cachePackageCompleteAction = BOOTSTRAPPER_CACHEPACKAGECOMPLETE_ACTION_NONE;
+
+            if (pCacheAction->fSkipUntilRetried)
+            {
+                // If this action was retried, let's make sure it will not be skipped any longer.
+                if (iRetryAction == i)
+                {
+                    pCacheAction->fSkipUntilRetried = FALSE;
+                }
+                else // skip the action.
+                {
+                    continue;
+                }
+            }
+
+            switch (pCacheAction->type)
+            {
+            case BURN_CACHE_ACTION_TYPE_CHECKPOINT:
+                dwCheckpoint = pCacheAction->checkpoint.dwId;
+                break;
+
+            case BURN_CACHE_ACTION_TYPE_LAYOUT_BUNDLE:
+                hr = LayoutBundle(pUX, pVariables, hPipe, pCacheAction->bundleLayout.sczExecutableName, pCacheAction->bundleLayout.sczLayoutDirectory, pCacheAction->bundleLayout.sczUnverifiedPath, qwSuccessfulCachedProgress, pPlan->qwCacheSizeTotal);
+                if (SUCCEEDED(hr))
+                {
+                    UpdateCacheSuccessProgress(pPlan, pCacheAction, &qwSuccessfulCachedProgress);
+                    ++(*pcOverallProgressTicks);
+
+                    hr = ReportOverallProgressTicks(pUX, FALSE, pPlan->cOverallProgressTicksTotal, *pcOverallProgressTicks);
+                    if (FAILED(hr))
+                    {
+                        LogErrorId(hr, MSG_USER_CANCELED, L"layout bundle", NULL, NULL);
+                    }
+                }
+                break;
+
+            case BURN_CACHE_ACTION_TYPE_PACKAGE_START:
+                iPackageStartAction = i; // if we retry this package, we'll start here in the plan.
+                iPackageCompleteAction = pCacheAction->packageStart.iPackageCompleteAction; // if we ignore this package, we'll start after the complete action in the plan.
+                pStartedPackage = pCacheAction->packageStart.pPackage;
+
+                hr = UserExperienceOnCachePackageBegin(pUX, pStartedPackage->sczId, pCacheAction->packageStart.cCachePayloads, pCacheAction->packageStart.qwCachePayloadSizeTotal);
+                if (FAILED(hr))
+                {
+                    LogErrorId(hr, MSG_USER_CANCELED, L"begin cache package", pStartedPackage->sczId, NULL);
+                }
+                break;
+
+            case BURN_CACHE_ACTION_TYPE_ACQUIRE_CONTAINER:
+                hr = AcquireContainerOrPayload(pUX, pVariables, pCacheAction->resolveContainer.pContainer, NULL, NULL, pCacheAction->resolveContainer.sczUnverifiedPath, qwSuccessfulCachedProgress, pPlan->qwCacheSizeTotal);
+                if (SUCCEEDED(hr))
+                {
+                    UpdateCacheSuccessProgress(pPlan, pCacheAction, &qwSuccessfulCachedProgress);
+                }
+                else
+                {
+                    LogErrorId(hr, MSG_FAILED_ACQUIRE_CONTAINER, pCacheAction->resolveContainer.pContainer->sczId, pCacheAction->resolveContainer.sczUnverifiedPath, NULL);
+                }
+                break;
+
+            case BURN_CACHE_ACTION_TYPE_EXTRACT_CONTAINER:
+                // If this action is to be skipped until the acquire action is not skipped and the other
+                // action is still being skipped then skip this action.
+                if (BURN_PLAN_INVALID_ACTION_INDEX != pCacheAction->extractContainer.iSkipUntilAcquiredByAction && pPlan->rgCacheActions[pCacheAction->extractContainer.iSkipUntilAcquiredByAction].fSkipUntilRetried)
+                {
+                    break;
+                }
+
+                hr = ExtractContainer(hSourceEngineFile, pCacheAction->extractContainer.pContainer, pCacheAction->extractContainer.sczContainerUnverifiedPath, pCacheAction->extractContainer.rgPayloads, pCacheAction->extractContainer.cPayloads);
+                if (FAILED(hr))
+                {
+                    LogErrorId(hr, MSG_FAILED_EXTRACT_CONTAINER, pCacheAction->extractContainer.pContainer->sczId, pCacheAction->extractContainer.sczContainerUnverifiedPath, NULL);
+                }
+                break;
+
+            case BURN_CACHE_ACTION_TYPE_LAYOUT_CONTAINER:
+                hr = LayoutOrCacheContainerOrPayload(pUX, hPipe, pCacheAction->layoutContainer.pContainer, pCacheAction->layoutContainer.pPackage, NULL, pPlan->rgContainerProgress[pCacheAction->layoutContainer.iProgress].fCachedDuringApply, qwSuccessfulCachedProgress, pPlan->qwCacheSizeTotal, pCacheAction->layoutContainer.sczLayoutDirectory, pCacheAction->layoutContainer.sczUnverifiedPath, pCacheAction->layoutContainer.fMove, pCacheAction->layoutContainer.cTryAgainAttempts, &fRetryContainerOrPayload);
+                if (SUCCEEDED(hr))
+                {
+                    UpdateCacheSuccessProgress(pPlan, pCacheAction, &qwSuccessfulCachedProgress);
+                }
+                else
+                {
+                    LogErrorId(hr, MSG_FAILED_LAYOUT_CONTAINER, pCacheAction->layoutContainer.pContainer->sczId, pCacheAction->layoutContainer.sczLayoutDirectory, pCacheAction->layoutContainer.sczUnverifiedPath);
+
+                    if (fRetryContainerOrPayload)
+                    {
+                        wzRetryId = pCacheAction->layoutContainer.pContainer->sczId;
+                        iRetryContainerOrPayloadAction = pCacheAction->layoutContainer.iTryAgainAction;
+
+                        ++pCacheAction->layoutContainer.cTryAgainAttempts;
+                    }
+                }
+                break;
+
+            case BURN_CACHE_ACTION_TYPE_ACQUIRE_PAYLOAD:
+                hr = AcquireContainerOrPayload(pUX, pVariables, NULL, pCacheAction->resolvePayload.pPackage, pCacheAction->resolvePayload.pPayload, pCacheAction->resolvePayload.sczUnverifiedPath, qwSuccessfulCachedProgress, pPlan->qwCacheSizeTotal);
+                if (SUCCEEDED(hr))
+                {
+                    UpdateCacheSuccessProgress(pPlan, pCacheAction, &qwSuccessfulCachedProgress);
+                }
+                else
+                {
+                    LogErrorId(hr, MSG_FAILED_ACQUIRE_PAYLOAD, pCacheAction->resolvePayload.pPayload->sczKey, pCacheAction->resolvePayload.sczUnverifiedPath, NULL);
+                }
+                break;
+
+            case BURN_CACHE_ACTION_TYPE_CACHE_PAYLOAD:
+                hr = LayoutOrCacheContainerOrPayload(pUX, pCacheAction->cachePayload.pPackage->fPerMachine ? hPipe : INVALID_HANDLE_VALUE, NULL, pCacheAction->cachePayload.pPackage, pCacheAction->cachePayload.pPayload, pPlan->rgPayloadProgress[pCacheAction->cachePayload.iProgress].fCachedDuringApply, qwSuccessfulCachedProgress, pPlan->qwCacheSizeTotal, NULL, pCacheAction->cachePayload.sczUnverifiedPath, pCacheAction->cachePayload.fMove, pCacheAction->cachePayload.cTryAgainAttempts, &fRetryContainerOrPayload);
+                if (SUCCEEDED(hr))
+                {
+                    UpdateCacheSuccessProgress(pPlan, pCacheAction, &qwSuccessfulCachedProgress);
+                }
+                else
+                {
+                    LogErrorId(hr, MSG_FAILED_CACHE_PAYLOAD, pCacheAction->cachePayload.pPayload->sczKey, pCacheAction->cachePayload.sczUnverifiedPath, NULL);
+
+                    if (fRetryContainerOrPayload)
+                    {
+                        wzRetryId = pCacheAction->cachePayload.pPayload->sczKey;
+                        iRetryContainerOrPayloadAction = pCacheAction->cachePayload.iTryAgainAction;
+
+                        ++pCacheAction->cachePayload.cTryAgainAttempts;
+                    }
+                }
+                break;
+
+            case BURN_CACHE_ACTION_TYPE_LAYOUT_PAYLOAD:
+                hr = LayoutOrCacheContainerOrPayload(pUX, hPipe, NULL, pCacheAction->layoutPayload.pPackage, pCacheAction->layoutPayload.pPayload, pPlan->rgPayloadProgress[pCacheAction->layoutPayload.iProgress].fCachedDuringApply, qwSuccessfulCachedProgress, pPlan->qwCacheSizeTotal, pCacheAction->layoutPayload.sczLayoutDirectory, pCacheAction->layoutPayload.sczUnverifiedPath, pCacheAction->layoutPayload.fMove, pCacheAction->layoutPayload.cTryAgainAttempts, &fRetryContainerOrPayload);
+                if (SUCCEEDED(hr))
+                {
+                    UpdateCacheSuccessProgress(pPlan, pCacheAction, &qwSuccessfulCachedProgress);
+                }
+                else
+                {
+                    LogErrorId(hr, MSG_FAILED_LAYOUT_PAYLOAD, pCacheAction->layoutPayload.pPayload->sczKey, pCacheAction->layoutPayload.sczLayoutDirectory, pCacheAction->layoutPayload.sczUnverifiedPath);
+
+                    if (fRetryContainerOrPayload)
+                    {
+                        wzRetryId = pCacheAction->layoutPayload.pPayload->sczKey;
+                        iRetryContainerOrPayloadAction = pCacheAction->layoutPayload.iTryAgainAction;
+
+                        ++pCacheAction->layoutPayload.cTryAgainAttempts;
+                    }
+                }
+                break;
+
+            case BURN_CACHE_ACTION_TYPE_PACKAGE_STOP:
+                AssertSz(pStartedPackage == pCacheAction->packageStop.pPackage, "Expected package started cached to be the same as the package checkpointed.");
+
+                hr = ReportOverallProgressTicks(pUX, FALSE, pPlan->cOverallProgressTicksTotal, *pcOverallProgressTicks + 1);
+                if (FAILED(hr))
+                {
+                    LogErrorId(hr, MSG_USER_CANCELED, L"end cache package", NULL, NULL);
+                }
+                else
+                {
+                    ++(*pcOverallProgressTicks);
+
+                    UserExperienceOnCachePackageComplete(pUX, pStartedPackage->sczId, hr, &cachePackageCompleteAction);
+
+                    pStartedPackage->hrCacheResult = hr;
+
+                    iPackageStartAction = BURN_PLAN_INVALID_ACTION_INDEX;
+                    iPackageCompleteAction = BURN_PLAN_INVALID_ACTION_INDEX;
+                    pStartedPackage = NULL;
+                }
+                break;
+
+            case BURN_CACHE_ACTION_TYPE_SIGNAL_SYNCPOINT:
+                if (!::SetEvent(pCacheAction->syncpoint.hEvent))
+                {
+                    ExitWithLastError(hr, "Failed to set syncpoint event.");
+                }
+                break;
+
+            default:
+                AssertSz(FALSE, "Unknown cache action.");
+                break;
+            }
+        }
+
+        if (BURN_PLAN_INVALID_ACTION_INDEX != iRetryContainerOrPayloadAction)
+        {
+            Assert(wzRetryId);
+
+            LogErrorId(hr, MSG_APPLY_RETRYING_PAYLOAD, wzRetryId, NULL, NULL);
+
+            iRetryAction = iRetryContainerOrPayloadAction;
+            fRetry = TRUE;
+        }
+        else if (pStartedPackage)
+        {
+            Assert(BURN_PLAN_INVALID_ACTION_INDEX != iPackageStartAction);
+            Assert(BURN_PLAN_INVALID_ACTION_INDEX != iPackageCompleteAction);
+
+            cachePackageCompleteAction = SUCCEEDED(hr) || pStartedPackage->fVital ? BOOTSTRAPPER_CACHEPACKAGECOMPLETE_ACTION_NONE : BOOTSTRAPPER_CACHEPACKAGECOMPLETE_ACTION_IGNORE;
+            UserExperienceOnCachePackageComplete(pUX, pStartedPackage->sczId, hr, &cachePackageCompleteAction);
+            if (BOOTSTRAPPER_CACHEPACKAGECOMPLETE_ACTION_RETRY == cachePackageCompleteAction)
+            {
+                LogErrorId(hr, MSG_APPLY_RETRYING_PACKAGE, pStartedPackage->sczId, NULL, NULL);
+
+                iRetryAction = iPackageStartAction;
+                fRetry = TRUE;
+            }
+            else if (BOOTSTRAPPER_CACHEPACKAGECOMPLETE_ACTION_IGNORE == cachePackageCompleteAction && !pStartedPackage->fVital) // ignore non-vital download failures.
+            {
+                LogId(REPORT_STANDARD, MSG_APPLY_CONTINUING_NONVITAL_PACKAGE, pStartedPackage->sczId, hr);
+
+                ++(*pcOverallProgressTicks); // add progress even though we didn't fully cache the package.
+
+                iRetryAction = iPackageCompleteAction + 1;
+                fRetry = TRUE;
+            }
+
+            pStartedPackage->hrCacheResult = hr;
+
+            iPackageStartAction = BURN_PLAN_INVALID_ACTION_INDEX;
+            iPackageCompleteAction = BURN_PLAN_INVALID_ACTION_INDEX;
+            pStartedPackage = NULL;
+        }
+        else
+        {
+            Assert(BURN_PLAN_INVALID_ACTION_INDEX == iPackageStartAction);
+            Assert(BURN_PLAN_INVALID_ACTION_INDEX == iPackageCompleteAction);
+        }
+    } while (fRetry);
+
+LExit:
+    Assert(NULL == pStartedPackage);
+    Assert(BURN_PLAN_INVALID_ACTION_INDEX == iPackageStartAction);
+    Assert(BURN_PLAN_INVALID_ACTION_INDEX == iPackageCompleteAction);
+
+    if (FAILED(hr))
+    {
+        DoRollbackCache(pUX, pPlan, hPipe, dwCheckpoint);
+        *pfRollback = TRUE;
+    }
+
+    // Clean up any remanents in the cache.
+    if (INVALID_HANDLE_VALUE != hPipe)
+    {
+        ElevationCacheCleanup(hPipe);
+    }
+
+    CacheCleanup(FALSE, pPlan->wzBundleId);
+
+    UserExperienceOnCacheComplete(pUX, hr);
+    return hr;
+}
+
+extern "C" HRESULT ApplyExecute(
+    __in BURN_ENGINE_STATE* pEngineState,
+    __in_opt HANDLE hCacheThread,
+    __inout DWORD* pcOverallProgressTicks,
+    __out BOOL* pfKeepRegistration,
+    __out BOOL* pfRollback,
+    __out BOOL* pfSuspend,
+    __out BOOTSTRAPPER_APPLY_RESTART* pRestart
+    )
+{
+    HRESULT hr = S_OK;
+    DWORD dwCheckpoint = 0;
+    BURN_EXECUTE_CONTEXT context = { };
+    BURN_ROLLBACK_BOUNDARY* pRollbackBoundary = NULL;
+    BOOL fSeekNextRollbackBoundary = FALSE;
+    BOOL fInTransaction = FALSE;
+
+    context.pUX = &pEngineState->userExperience;
+    context.cExecutePackagesTotal = pEngineState->plan.cExecutePackagesTotal;
+    context.pcOverallProgressTicks = pcOverallProgressTicks;
+
+    // Send execute begin to BA.
+    hr = UserExperienceOnExecuteBegin(&pEngineState->userExperience, pEngineState->plan.cExecutePackagesTotal);
+    ExitOnRootFailure(hr, "BA aborted execute begin.");
+
+    // Do execute actions.
+    for (DWORD i = 0; i < pEngineState->plan.cExecuteActions; ++i)
+    {
+        BURN_EXECUTE_ACTION* pExecuteAction = &pEngineState->plan.rgExecuteActions[i];
+        if (pExecuteAction->fDeleted)
+        {
+            continue;
+        }
+
+        // Transaction end/start
+        if (BURN_EXECUTE_ACTION_TYPE_ROLLBACK_BOUNDARY == pExecuteAction->type)
+        {
+            // End previous transaction
+            if (fInTransaction)
+            {
+                LogString(REPORT_STANDARD, "Committing MSI transaction\n");
+                hr = DoMsiCommitTransaction(&context, pEngineState);
+                ExitOnFailure(hr, "Failed committing an MSI transaction");
+                fInTransaction = FALSE;
+            }
+
+            // Start New transaction
+            if (!fInTransaction && pExecuteAction->rollbackBoundary.pRollbackBoundary && pExecuteAction->rollbackBoundary.pRollbackBoundary->fTransaction)
+            {
+                // Transactions don't go together with DisableRollback.
+                if (pEngineState->fDisableRollback)
+                {
+                    LogString(REPORT_STANDARD, "Ignoring Transaction flag due to DisableRollback flag\n");
+                }
+                else
+                {
+                    LogString(REPORT_STANDARD, "Starting a new MSI transaction\n");
+                    hr = DoMsiBeginTransaction(&context, pEngineState);
+                    ExitOnFailure(hr, "Failed beginning an MSI transaction");
+                    fInTransaction = TRUE;
+                }
+            }
+        }
+
+        // If we are seeking the next rollback boundary, skip if this action wasn't it.
+        if (fSeekNextRollbackBoundary)
+        {
+            if (BURN_EXECUTE_ACTION_TYPE_ROLLBACK_BOUNDARY == pExecuteAction->type)
+            {
+                continue;
+            }
+            else
+            {
+                fSeekNextRollbackBoundary = FALSE;
+            }
+        }
+
+        // Execute the action.
+        hr = DoExecuteAction(pEngineState, pExecuteAction, hCacheThread, &context, &pRollbackBoundary, &dwCheckpoint, pfKeepRegistration, pfSuspend, pRestart);
+
+        if (*pfSuspend || BOOTSTRAPPER_APPLY_RESTART_INITIATED == *pRestart)
+        {
+            if (fInTransaction)
+            {
+                hr = E_INVALIDSTATE;
+                LogString(REPORT_ERROR, "Ilegal state: Reboot requested within an MSI transaction. Transaction will rollback.");
+            }
+            else
+            {
+                ExitFunction();
+            }
+        }
+
+        if (FAILED(hr))
+        {
+            // If we failed, but rollback is disabled just bail with our error code.
+            if (pEngineState->fDisableRollback)
+            {
+                *pfRollback = TRUE;
+                break;
+            }
+            else // the action failed, roll back to previous rollback boundary.
+            {
+                HRESULT hrRollback = DoRollbackActions(pEngineState, &context, dwCheckpoint, fInTransaction, pfKeepRegistration, pRestart);
+                UNREFERENCED_PARAMETER(hrRollback);
+                fInTransaction = FALSE;
+
+                // If the rollback boundary is vital, end execution here.
+                if (pRollbackBoundary && pRollbackBoundary->fVital)
+                {
+                    *pfRollback = TRUE;
+                    break;
+                }
+
+                // Move forward to next rollback boundary.
+                fSeekNextRollbackBoundary = TRUE;
+            }
+        }
+    }
+
+    if (fInTransaction)
+    {
+        LogString(REPORT_STANDARD, "Committing an MSI transaction\n");
+        hr = DoMsiCommitTransaction(&context, pEngineState);
+        ExitOnFailure(hr, "Failed committing an MSI transaction");
+        fInTransaction = FALSE;
+    }
+
+LExit:
+    // Send execute complete to BA.
+    UserExperienceOnExecuteComplete(&pEngineState->userExperience, hr);
+
+    return hr;
+}
+
+extern "C" void ApplyClean(
+    __in BURN_USER_EXPERIENCE* /*pUX*/,
+    __in BURN_PLAN* pPlan,
+    __in HANDLE hPipe
+    )
+{
+    HRESULT hr = S_OK;
+
+    for (DWORD i = 0; i < pPlan->cCleanActions; ++i)
+    {
+        BURN_CLEAN_ACTION* pCleanAction = pPlan->rgCleanActions + i;
+
+        hr = CleanPackage(hPipe, pCleanAction->pPackage);
+    }
+}
+
+
+// internal helper functions
+
+static HRESULT ExecuteDependentRegistrationActions(
+    __in HANDLE hPipe,
+    __in const BURN_REGISTRATION* pRegistration,
+    __in_ecount(cActions) const BURN_DEPENDENT_REGISTRATION_ACTION* rgActions,
+    __in DWORD cActions
+    )
+{
+    HRESULT hr = S_OK;
+
+    for (DWORD iAction = 0; iAction < cActions; ++iAction)
+    {
+        const BURN_DEPENDENT_REGISTRATION_ACTION* pAction = rgActions + iAction;
+
+        if (pRegistration->fPerMachine)
+        {
+            hr = ElevationProcessDependentRegistration(hPipe, pAction);
+            ExitOnFailure(hr, "Failed to execute dependent registration action.");
+        }
+        else
+        {
+            hr = DependencyProcessDependentRegistration(pRegistration, pAction);
+            ExitOnFailure(hr, "Failed to process dependency registration action.");
+        }
+    }
+
+LExit:
+    return hr;
+}
+
+static HRESULT ExtractContainer(
+    __in HANDLE hSourceEngineFile,
+    __in BURN_CONTAINER* pContainer,
+    __in_z LPCWSTR wzContainerPath,
+    __in_ecount(cExtractPayloads) BURN_EXTRACT_PAYLOAD* rgExtractPayloads,
+    __in DWORD cExtractPayloads
+    )
+{
+    HRESULT hr = S_OK;
+    BURN_CONTAINER_CONTEXT context = { };
+    HANDLE hContainerHandle = INVALID_HANDLE_VALUE;
+    LPWSTR sczExtractPayloadId = NULL;
+
+    // If the container is actually attached, then it was planned to be acquired through hSourceEngineFile.
+    if (pContainer->fActuallyAttached)
+    {
+        hContainerHandle = hSourceEngineFile;
+    }
+
+    hr = ContainerOpen(&context, pContainer, hContainerHandle, wzContainerPath);
+    ExitOnFailure(hr, "Failed to open container: %ls.", pContainer->sczId);
+
+    while (S_OK == (hr = ContainerNextStream(&context, &sczExtractPayloadId)))
+    {
+        BOOL fExtracted = FALSE;
+
+        for (DWORD iExtract = 0; iExtract < cExtractPayloads; ++iExtract)
+        {
+            BURN_EXTRACT_PAYLOAD* pExtract = rgExtractPayloads + iExtract;
+            if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, sczExtractPayloadId, -1, pExtract->pPayload->sczSourcePath, -1))
+            {
+                // TODO: Send progress when extracting stream to file.
+                hr = ContainerStreamToFile(&context, pExtract->sczUnverifiedPath);
+                ExitOnFailure(hr, "Failed to extract payload: %ls from container: %ls", sczExtractPayloadId, pContainer->sczId);
+
+                fExtracted = TRUE;
+                break;
+            }
+        }
+
+        if (!fExtracted)
+        {
+            hr = ContainerSkipStream(&context);
+            ExitOnFailure(hr, "Failed to skip the extraction of payload: %ls from container: %ls", sczExtractPayloadId, pContainer->sczId);
+        }
+    }
+
+    if (E_NOMOREITEMS == hr)
+    {
+        hr = S_OK;
+    }
+    ExitOnFailure(hr, "Failed to extract all payloads from container: %ls", pContainer->sczId);
+
+LExit:
+    ReleaseStr(sczExtractPayloadId);
+    ContainerClose(&context);
+
+    return hr;
+}
+
+static void UpdateCacheSuccessProgress(
+    __in BURN_PLAN* pPlan,
+    __in BURN_CACHE_ACTION* pCacheAction,
+    __inout DWORD64* pqwSuccessfulCachedProgress
+    )
+{
+    switch (pCacheAction->type)
+    {
+    case BURN_CACHE_ACTION_TYPE_LAYOUT_BUNDLE:
+        *pqwSuccessfulCachedProgress += pCacheAction->bundleLayout.qwBundleSize;
+        break;
+
+    case BURN_CACHE_ACTION_TYPE_ACQUIRE_CONTAINER:
+        if (!pPlan->rgContainerProgress[pCacheAction->resolveContainer.iProgress].fCachedDuringApply)
+        {
+            pPlan->rgContainerProgress[pCacheAction->resolveContainer.iProgress].fCachedDuringApply = TRUE;
+            *pqwSuccessfulCachedProgress += pCacheAction->resolveContainer.pContainer->qwFileSize;
+        }
+        break;
+
+    case BURN_CACHE_ACTION_TYPE_LAYOUT_CONTAINER:
+        if (!pPlan->rgContainerProgress[pCacheAction->layoutContainer.iProgress].fCachedDuringApply)
+        {
+            pPlan->rgContainerProgress[pCacheAction->layoutContainer.iProgress].fCachedDuringApply = TRUE;
+            *pqwSuccessfulCachedProgress += pCacheAction->layoutContainer.pContainer->qwFileSize;
+        }
+        break;
+
+    case BURN_CACHE_ACTION_TYPE_ACQUIRE_PAYLOAD:
+        if (!pPlan->rgPayloadProgress[pCacheAction->resolvePayload.iProgress].fCachedDuringApply)
+        {
+            pPlan->rgPayloadProgress[pCacheAction->resolvePayload.iProgress].fCachedDuringApply = TRUE;
+            *pqwSuccessfulCachedProgress += pCacheAction->resolvePayload.pPayload->qwFileSize;
+        }
+        break;
+
+    case BURN_CACHE_ACTION_TYPE_CACHE_PAYLOAD:
+        if (!pPlan->rgPayloadProgress[pCacheAction->cachePayload.iProgress].fCachedDuringApply)
+        {
+            pPlan->rgPayloadProgress[pCacheAction->cachePayload.iProgress].fCachedDuringApply = TRUE;
+            *pqwSuccessfulCachedProgress += pCacheAction->cachePayload.pPayload->qwFileSize;
+        }
+        break;
+
+    case BURN_CACHE_ACTION_TYPE_LAYOUT_PAYLOAD:
+        if (!pPlan->rgPayloadProgress[pCacheAction->layoutPayload.iProgress].fCachedDuringApply)
+        {
+            pPlan->rgPayloadProgress[pCacheAction->layoutPayload.iProgress].fCachedDuringApply = TRUE;
+            *pqwSuccessfulCachedProgress += pCacheAction->layoutPayload.pPayload->qwFileSize;
+        }
+        break;
+
+    default:
+        AssertSz(FALSE, "Unexpected cache action type.");
+        break;
+    }
+}
+
+static HRESULT LayoutBundle(
+    __in BURN_USER_EXPERIENCE* pUX,
+    __in BURN_VARIABLES* pVariables,
+    __in HANDLE hPipe,
+    __in_z LPCWSTR wzExecutableName,
+    __in_z LPCWSTR wzLayoutDirectory,
+    __in_z LPCWSTR wzUnverifiedPath,
+    __in DWORD64 qwSuccessfulCacheProgress,
+    __in DWORD64 qwTotalCacheSize
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR sczBundlePath = NULL;
+    LPWSTR sczDestinationPath = NULL;
+    int nEquivalentPaths = 0;
+    BURN_CACHE_ACQUIRE_PROGRESS_CONTEXT progress = { };
+    BOOL fRetry = FALSE;
+    BOOL fRetryAcquire = FALSE;
+
+    hr = VariableGetString(pVariables, BURN_BUNDLE_SOURCE_PROCESS_PATH, &sczBundlePath);
+    if (FAILED(hr))
+    {
+        if  (E_NOTFOUND != hr)
+        {
+            ExitOnFailure(hr, "Failed to get path to bundle source process path to layout.");
+        }
+
+        hr = PathForCurrentProcess(&sczBundlePath, NULL);
+        ExitOnFailure(hr, "Failed to get path to bundle to layout.");
+    }
+
+    hr = PathConcat(wzLayoutDirectory, wzExecutableName, &sczDestinationPath);
+    ExitOnFailure(hr, "Failed to concat layout path for bundle.");
+
+    // If the destination path is the currently running bundle, bail.
+    hr = PathCompare(sczBundlePath, sczDestinationPath, &nEquivalentPaths);
+    ExitOnFailure(hr, "Failed to determine if layout bundle path was equivalent with current process path.");
+
+    if (CSTR_EQUAL == nEquivalentPaths)
+    {
+        ExitFunction1(hr = S_OK);
+    }
+
+    progress.pUX = pUX;
+    progress.qwCacheProgress = qwSuccessfulCacheProgress;
+    progress.qwTotalCacheSize = qwTotalCacheSize;
+
+    do
+    {
+        hr = S_OK;
+        fRetry = FALSE;
+
+        for (;;)
+        {
+            fRetryAcquire = FALSE;
+            progress.fCancel = FALSE;
+
+            hr = UserExperienceOnCacheAcquireBegin(pUX, NULL, NULL, BOOTSTRAPPER_CACHE_OPERATION_COPY, sczBundlePath);
+            ExitOnRootFailure(hr, "BA aborted cache acquire begin.");
+
+            hr = CopyPayload(&progress, sczBundlePath, wzUnverifiedPath);
+            // Error handling happens after sending complete message to BA.
+
+            UserExperienceOnCacheAcquireComplete(pUX, NULL, NULL, hr, &fRetryAcquire);
+            if (fRetryAcquire)
+            {
+                continue;
+            }
+
+            ExitOnFailure(hr, "Failed to copy bundle from: '%ls' to: '%ls'", sczBundlePath, wzUnverifiedPath);
+            break;
+        }
+
+        do
+        {
+            hr = UserExperienceOnCacheVerifyBegin(pUX, NULL, NULL);
+            ExitOnRootFailure(hr, "BA aborted cache verify begin.");
+
+            if (INVALID_HANDLE_VALUE != hPipe)
+            {
+                hr = ElevationLayoutBundle(hPipe, wzLayoutDirectory, wzUnverifiedPath);
+            }
+            else
+            {
+                hr = CacheLayoutBundle(wzExecutableName, wzLayoutDirectory, wzUnverifiedPath);
+            }
+
+            BOOTSTRAPPER_CACHEVERIFYCOMPLETE_ACTION action = BOOTSTRAPPER_CACHEVERIFYCOMPLETE_ACTION_NONE;
+            UserExperienceOnCacheVerifyComplete(pUX, NULL, NULL, hr, &action);
+            if (BOOTSTRAPPER_CACHEVERIFYCOMPLETE_ACTION_RETRYVERIFICATION == action)
+            {
+                hr = S_FALSE; // retry verify.
+            }
+            else if (BOOTSTRAPPER_CACHEVERIFYCOMPLETE_ACTION_RETRYACQUISITION == action)
+            {
+                fRetry = TRUE; // go back and retry acquire.
+            }
+        } while (S_FALSE == hr);
+    } while (fRetry);
+    LogExitOnFailure(hr, MSG_FAILED_LAYOUT_BUNDLE, "Failed to layout bundle: %ls to layout directory: %ls", sczBundlePath, wzLayoutDirectory);
+
+LExit:
+    ReleaseStr(sczDestinationPath);
+    ReleaseStr(sczBundlePath);
+
+    return hr;
+}
+
+static HRESULT AcquireContainerOrPayload(
+    __in BURN_USER_EXPERIENCE* pUX,
+    __in BURN_VARIABLES* pVariables,
+    __in_opt BURN_CONTAINER* pContainer,
+    __in_opt BURN_PACKAGE* pPackage,
+    __in_opt BURN_PAYLOAD* pPayload,
+    __in LPCWSTR wzDestinationPath,
+    __in DWORD64 qwSuccessfulCacheProgress,
+    __in DWORD64 qwTotalCacheSize
+    )
+{
+    AssertSz(pContainer || pPayload, "Must provide a container or a payload.");
+
+    HRESULT hr = S_OK;
+    int nEquivalentPaths = 0;
+    LPCWSTR wzPackageOrContainerId = pContainer ? pContainer->sczId : pPackage ? pPackage->sczId : NULL;
+    LPCWSTR wzPayloadId = pPayload ? pPayload->sczKey : NULL;
+    LPCWSTR wzRelativePath = pContainer ? pContainer->sczFilePath : pPayload->sczFilePath;
+    LPWSTR sczSourceFullPath = NULL;
+    BURN_CACHE_ACQUIRE_PROGRESS_CONTEXT progress = { };
+    BOOL fRetry = FALSE;
+
+    progress.pContainer = pContainer;
+    progress.pPackage = pPackage;
+    progress.pPayload = pPayload;
+    progress.pUX = pUX;
+    progress.qwCacheProgress = qwSuccessfulCacheProgress;
+    progress.qwTotalCacheSize = qwTotalCacheSize;
+
+    do
+    {
+        LPCWSTR wzDownloadUrl = pContainer ? pContainer->downloadSource.sczUrl : pPayload->downloadSource.sczUrl;
+        LPCWSTR wzSourcePath = pContainer ? pContainer->sczSourcePath : pPayload->sczSourcePath;
+
+        BOOL fFoundLocal = FALSE;
+        BOOL fCopy = FALSE;
+        BOOL fDownload = FALSE;
+
+        fRetry = FALSE;
+        progress.fCancel = FALSE;
+
+        hr = CacheFindLocalSource(wzSourcePath, pVariables, &fFoundLocal, &sczSourceFullPath);
+        ExitOnFailure(hr, "Failed to search local source.");
+        
+        if (fFoundLocal) // the file exists locally, so copy it.
+        {
+            // If the source path and destination path are different, do the copy (otherwise there's no point).
+            hr = PathCompare(sczSourceFullPath, wzDestinationPath, &nEquivalentPaths);
+            ExitOnFailure(hr, "Failed to determine if payload source path was equivalent to the destination path.");
+
+            fCopy = (CSTR_EQUAL != nEquivalentPaths);
+        }
+        else // can't find the file locally, so prompt for source.
+        {
+            DWORD dwLogId = pContainer ? (wzPayloadId ? MSG_PROMPT_CONTAINER_PAYLOAD_SOURCE : MSG_PROMPT_CONTAINER_SOURCE) : pPackage ? MSG_PROMPT_PACKAGE_PAYLOAD_SOURCE : MSG_PROMPT_BUNDLE_PAYLOAD_SOURCE;
+            LogId(REPORT_STANDARD, dwLogId, wzPackageOrContainerId ? wzPackageOrContainerId : L"", wzPayloadId ? wzPayloadId : L"", sczSourceFullPath);
+
+            hr = PromptForSource(pUX, wzPackageOrContainerId, wzPayloadId, sczSourceFullPath, wzDownloadUrl, &fRetry, &fDownload);
+
+            // If the BA requested download then ensure a download url is available (it may have been set
+            // during PromptForSource so we need to check again).
+            if (fDownload)
+            {
+                wzDownloadUrl = pContainer ? pContainer->downloadSource.sczUrl : pPayload->downloadSource.sczUrl;
+                if (!wzDownloadUrl || !*wzDownloadUrl)
+                {
+                    hr = E_INVALIDARG;
+                }
+            }
+
+            // Log the error
+            LogExitOnFailure(hr, MSG_PAYLOAD_FILE_NOT_PRESENT, "Failed while prompting for source (original path '%ls').", sczSourceFullPath);
+        }
+
+        if (fCopy)
+        {
+            hr = UserExperienceOnCacheAcquireBegin(pUX, wzPackageOrContainerId, wzPayloadId, BOOTSTRAPPER_CACHE_OPERATION_COPY, sczSourceFullPath);
+            ExitOnRootFailure(hr, "BA aborted cache acquire begin.");
+
+            hr = CopyPayload(&progress, sczSourceFullPath, wzDestinationPath);
+            // Error handling happens after sending complete message to BA.
+
+            // We successfully copied from a source location, set that as the last used source.
+            if (SUCCEEDED(hr))
+            {
+                CacheSetLastUsedSource(pVariables, sczSourceFullPath, wzRelativePath);
+            }
+        }
+        else if (fDownload)
+        {
+            hr = UserExperienceOnCacheAcquireBegin(pUX, wzPackageOrContainerId, wzPayloadId, BOOTSTRAPPER_CACHE_OPERATION_DOWNLOAD, wzDownloadUrl);
+            ExitOnRootFailure(hr, "BA aborted cache download payload begin.");
+
+            hr = DownloadPayload(&progress, wzDestinationPath);
+            // Error handling happens after sending complete message to BA.
+        }
+
+        if (fCopy || fDownload)
+        {
+            UserExperienceOnCacheAcquireComplete(pUX, wzPackageOrContainerId, wzPayloadId, hr, &fRetry);
+            if (fRetry)
+            {
+                hr = S_OK;
+            }
+        }
+        ExitOnFailure(hr, "Failed to acquire payload from: '%ls' to working path: '%ls'", fCopy ? sczSourceFullPath : wzDownloadUrl, wzDestinationPath);
+    } while (fRetry);
+    ExitOnFailure(hr, "Failed to find external payload to cache.");
+
+LExit:
+    ReleaseStr(sczSourceFullPath);
+
+    return hr;
+}
+
+static HRESULT LayoutOrCacheContainerOrPayload(
+    __in BURN_USER_EXPERIENCE* pUX,
+    __in HANDLE hPipe,
+    __in_opt BURN_CONTAINER* pContainer,
+    __in_opt BURN_PACKAGE* pPackage,
+    __in_opt BURN_PAYLOAD* pPayload,
+    __in BOOL fAlreadyProvidedProgress,
+    __in DWORD64 qwSuccessfulCachedProgress,
+    __in DWORD64 qwTotalCacheSize,
+    __in_z_opt LPCWSTR wzLayoutDirectory,
+    __in_z LPCWSTR wzUnverifiedPath,
+    __in BOOL fMove,
+    __in DWORD cTryAgainAttempts,
+    __out BOOL* pfRetry
+    )
+{
+    HRESULT hr = S_OK;
+    LPCWSTR wzPackageOrContainerId = pContainer ? pContainer->sczId : pPackage ? pPackage->sczId : L"";
+    LPCWSTR wzPayloadId = pPayload ? pPayload->sczKey : L"";
+    LARGE_INTEGER liContainerOrPayloadSize = { };
+    LARGE_INTEGER liZero = { };
+    BURN_CACHE_ACQUIRE_PROGRESS_CONTEXT progress = { };
+
+    liContainerOrPayloadSize.QuadPart = pContainer ? pContainer->qwFileSize : pPayload->qwFileSize;
+
+    progress.pContainer = pContainer;
+    progress.pPackage = pPackage;
+    progress.pPayload = pPayload;
+    progress.pUX = pUX;
+    progress.qwTotalCacheSize = qwTotalCacheSize;
+    if (fAlreadyProvidedProgress)
+    {
+        Assert(qwSuccessfulCachedProgress >= static_cast<DWORD64>(liContainerOrPayloadSize.QuadPart));
+        progress.qwCacheProgress = qwSuccessfulCachedProgress - liContainerOrPayloadSize.QuadPart; // remove the payload size, since it was marked successful thus included in the successful size already.
+    }
+    else
+    {
+        progress.qwCacheProgress = qwSuccessfulCachedProgress;
+    }
+
+    *pfRetry = FALSE;
+
+    do
+    {
+        hr = UserExperienceOnCacheVerifyBegin(pUX, wzPackageOrContainerId, wzPayloadId);
+        ExitOnRootFailure(hr, "BA aborted cache verify begin.");
+
+        if (INVALID_HANDLE_VALUE != hPipe) // pass the decision off to the elevated process.
+        {
+            hr = ElevationCacheOrLayoutContainerOrPayload(hPipe, pContainer, pPackage, pPayload, wzLayoutDirectory, wzUnverifiedPath, fMove);
+        }
+        else if (wzLayoutDirectory) // layout the container or payload.
+        {
+            if (pContainer)
+            {
+                hr = CacheLayoutContainer(pContainer, wzLayoutDirectory, wzUnverifiedPath, fMove);
+            }
+            else
+            {
+                hr = CacheLayoutPayload(pPayload, wzLayoutDirectory, wzUnverifiedPath, fMove);
+            }
+        }
+        else // complete the payload.
+        {
+            Assert(!pContainer);
+            Assert(pPackage);
+
+            hr = CacheCompletePayload(pPackage->fPerMachine, pPayload, pPackage->sczCacheId, wzUnverifiedPath, fMove);
+        }
+
+        // If succeeded, send 100% complete here. If the payload was already cached this is the first progress the BA
+        // will get.
+        if (SUCCEEDED(hr))
+        {
+            CacheProgressRoutine(liContainerOrPayloadSize, liContainerOrPayloadSize, liZero, liZero, 0, 0, INVALID_HANDLE_VALUE, INVALID_HANDLE_VALUE, &progress);
+            if (progress.fCancel)
+            {
+                hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
+            }
+            else if (progress.fError)
+            {
+                hr = HRESULT_FROM_WIN32(ERROR_INSTALL_FAILURE);
+            }
+            ExitOnRootFailure(hr, "BA aborted verify of %hs: %ls", pContainer ? "container" : "payload", pContainer ? wzPackageOrContainerId : wzPayloadId);
+        }
+
+        BOOTSTRAPPER_CACHEVERIFYCOMPLETE_ACTION action = FAILED(hr) && cTryAgainAttempts < BURN_CACHE_MAX_RECOMMENDED_VERIFY_TRYAGAIN_ATTEMPTS ? BOOTSTRAPPER_CACHEVERIFYCOMPLETE_ACTION_RETRYACQUISITION : BOOTSTRAPPER_CACHEVERIFYCOMPLETE_ACTION_NONE;
+        UserExperienceOnCacheVerifyComplete(pUX, wzPackageOrContainerId, wzPayloadId, hr, &action);
+        if (BOOTSTRAPPER_CACHEVERIFYCOMPLETE_ACTION_RETRYVERIFICATION == action)
+        {
+            hr = S_FALSE; // retry verify.
+        }
+        else if (BOOTSTRAPPER_CACHEVERIFYCOMPLETE_ACTION_RETRYACQUISITION == action)
+        {
+            *pfRetry = TRUE; // go back and retry acquire.
+        }
+    } while (S_FALSE == hr);
+
+LExit:
+    return hr;
+}
+
+static HRESULT PromptForSource(
+    __in BURN_USER_EXPERIENCE* pUX,
+    __in_z LPCWSTR wzPackageOrContainerId,
+    __in_z_opt LPCWSTR wzPayloadId,
+    __in_z LPCWSTR wzLocalSource,
+    __in_z_opt LPCWSTR wzDownloadSource,
+    __inout BOOL* pfRetry,
+    __inout BOOL* pfDownload
+    )
+{
+    HRESULT hr = S_OK;
+    BOOTSTRAPPER_RESOLVESOURCE_ACTION action = BOOTSTRAPPER_RESOLVESOURCE_ACTION_NONE;
+
+    UserExperienceDeactivateEngine(pUX);
+
+    hr = UserExperienceOnResolveSource(pUX, wzPackageOrContainerId, wzPayloadId, wzLocalSource, wzDownloadSource, &action);
+    if (FAILED(hr))
+    {
+        ExitFunction();
+    }
+
+    switch (action)
+    {
+    case BOOTSTRAPPER_RESOLVESOURCE_ACTION_NONE:
+        hr = E_FILENOTFOUND;
+        break;
+
+    case BOOTSTRAPPER_RESOLVESOURCE_ACTION_RETRY:
+        *pfRetry = TRUE;
+        break;
+
+    case BOOTSTRAPPER_RESOLVESOURCE_ACTION_DOWNLOAD:
+        *pfDownload = TRUE;
+        break;
+
+    default:
+        hr = E_INVALIDARG;
+        break;
+    }
+
+LExit:
+    UserExperienceActivateEngine(pUX, NULL);
+    return hr;
+}
+
+static HRESULT CopyPayload(
+    __in BURN_CACHE_ACQUIRE_PROGRESS_CONTEXT* pProgress,
+    __in_z LPCWSTR wzSourcePath,
+    __in_z LPCWSTR wzDestinationPath
+    )
+{
+    HRESULT hr = S_OK;
+    DWORD dwFileAttributes = 0;
+    LPCWSTR wzPackageOrContainerId = pProgress->pContainer ? pProgress->pContainer->sczId : pProgress->pPackage ? pProgress->pPackage->sczId : L"";
+    LPCWSTR wzPayloadId = pProgress->pPayload ? pProgress->pPayload->sczKey : L"";
+
+    DWORD dwLogId = pProgress->pContainer ? (pProgress->pPayload ? MSG_ACQUIRE_CONTAINER_PAYLOAD : MSG_ACQUIRE_CONTAINER) : pProgress->pPackage ? MSG_ACQUIRE_PACKAGE_PAYLOAD : MSG_ACQUIRE_BUNDLE_PAYLOAD;
+    LogId(REPORT_STANDARD, dwLogId, wzPackageOrContainerId, wzPayloadId, "copy", wzSourcePath);
+
+    // If the destination file already exists, clear the readonly bit to avoid E_ACCESSDENIED.
+    if (FileExistsEx(wzDestinationPath, &dwFileAttributes))
+    {
+        if (FILE_ATTRIBUTE_READONLY & dwFileAttributes)
+        {
+            dwFileAttributes &= ~FILE_ATTRIBUTE_READONLY;
+            if (!::SetFileAttributes(wzDestinationPath, dwFileAttributes))
+            {
+                ExitWithLastError(hr, "Failed to clear readonly bit on payload destination path: %ls", wzDestinationPath);
+            }
+        }
+    }
+
+    if (!::CopyFileExW(wzSourcePath, wzDestinationPath, CacheProgressRoutine, pProgress, &pProgress->fCancel, 0))
+    {
+        if (pProgress->fCancel)
+        {
+            hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
+            ExitOnRootFailure(hr, "BA aborted copy of payload from: '%ls' to: %ls.", wzSourcePath, wzDestinationPath);
+        }
+        else
+        {
+            ExitWithLastError(hr, "Failed attempt to copy payload from: '%ls' to: %ls.", wzSourcePath, wzDestinationPath);
+        }
+    }
+
+LExit:
+    return hr;
+}
+
+static HRESULT DownloadPayload(
+    __in BURN_CACHE_ACQUIRE_PROGRESS_CONTEXT* pProgress,
+    __in_z LPCWSTR wzDestinationPath
+    )
+{
+    HRESULT hr = S_OK;
+    DWORD dwFileAttributes = 0;
+    LPCWSTR wzPackageOrContainerId = pProgress->pContainer ? pProgress->pContainer->sczId : pProgress->pPackage ? pProgress->pPackage->sczId : L"";
+    LPCWSTR wzPayloadId = pProgress->pPayload ? pProgress->pPayload->sczKey : L"";
+    DOWNLOAD_SOURCE* pDownloadSource = pProgress->pContainer ? &pProgress->pContainer->downloadSource : &pProgress->pPayload->downloadSource;
+    DWORD64 qwDownloadSize = pProgress->pContainer ? pProgress->pContainer->qwFileSize : pProgress->pPayload->qwFileSize;
+    DOWNLOAD_CACHE_CALLBACK cacheCallback = { };
+    DOWNLOAD_AUTHENTICATION_CALLBACK authenticationCallback = { };
+    APPLY_AUTHENTICATION_REQUIRED_DATA authenticationData = { };
+
+    DWORD dwLogId = pProgress->pContainer ? (pProgress->pPayload ? MSG_ACQUIRE_CONTAINER_PAYLOAD : MSG_ACQUIRE_CONTAINER) : pProgress->pPackage ? MSG_ACQUIRE_PACKAGE_PAYLOAD : MSG_ACQUIRE_BUNDLE_PAYLOAD;
+    LogId(REPORT_STANDARD, dwLogId, wzPackageOrContainerId, wzPayloadId, "download", pDownloadSource->sczUrl);
+
+    // If the destination file already exists, clear the readonly bit to avoid E_ACCESSDENIED.
+    if (FileExistsEx(wzDestinationPath, &dwFileAttributes))
+    {
+        if (FILE_ATTRIBUTE_READONLY & dwFileAttributes)
+        {
+            dwFileAttributes &= ~FILE_ATTRIBUTE_READONLY;
+            if (!::SetFileAttributes(wzDestinationPath, dwFileAttributes))
+            {
+                ExitWithLastError(hr, "Failed to clear readonly bit on payload destination path: %ls", wzDestinationPath);
+            }
+        }
+    }
+
+    cacheCallback.pfnProgress = CacheProgressRoutine;
+    cacheCallback.pfnCancel = NULL; // TODO: set this
+    cacheCallback.pv = pProgress;
+   
+    // If the protocol is specially marked, "bits" let's use that.
+    if (L'b' == pDownloadSource->sczUrl[0] &&
+        L'i' == pDownloadSource->sczUrl[1] &&
+        L't' == pDownloadSource->sczUrl[2] &&
+        L's' == pDownloadSource->sczUrl[3] &&
+        (L':' == pDownloadSource->sczUrl[4] || (L's' == pDownloadSource->sczUrl[4] && L':' == pDownloadSource->sczUrl[5]))
+        )
+    {
+        hr = BitsDownloadUrl(&cacheCallback, pDownloadSource, wzDestinationPath);
+    }
+    else // wininet handles everything else.
+    {
+        authenticationData.pUX = pProgress->pUX;
+        authenticationData.wzPackageOrContainerId = wzPackageOrContainerId;
+        authenticationData.wzPayloadId = wzPayloadId;
+        authenticationCallback.pv =  static_cast<LPVOID>(&authenticationData);
+        authenticationCallback.pfnAuthenticate = &AuthenticationRequired;
+        
+        hr = DownloadUrl(pDownloadSource, qwDownloadSize, wzDestinationPath, &cacheCallback, &authenticationCallback);
+    }
+    ExitOnFailure(hr, "Failed attempt to download URL: '%ls' to: '%ls'", pDownloadSource->sczUrl, wzDestinationPath);
+
+LExit:
+    return hr;
+}
+
+static HRESULT WINAPI AuthenticationRequired(
+    __in LPVOID pData,
+    __in HINTERNET hUrl,
+    __in long lHttpCode,
+    __out BOOL* pfRetrySend,
+    __out BOOL* pfRetry
+    )
+{
+    Assert(401 == lHttpCode || 407 == lHttpCode);
+
+    HRESULT hr = S_OK;
+    DWORD er = ERROR_SUCCESS;
+    BOOTSTRAPPER_ERROR_TYPE errorType = (401 == lHttpCode) ? BOOTSTRAPPER_ERROR_TYPE_HTTP_AUTH_SERVER : BOOTSTRAPPER_ERROR_TYPE_HTTP_AUTH_PROXY;
+    LPWSTR sczError = NULL;
+    int nResult = IDNOACTION;
+
+    *pfRetrySend = FALSE;
+    *pfRetry = FALSE;
+
+    hr = StrAllocFromError(&sczError, HRESULT_FROM_WIN32(ERROR_ACCESS_DENIED), NULL);
+    ExitOnFailure(hr, "Failed to allocation error string.");
+
+    APPLY_AUTHENTICATION_REQUIRED_DATA* authenticationData = reinterpret_cast<APPLY_AUTHENTICATION_REQUIRED_DATA*>(pData);
+
+    UserExperienceOnError(authenticationData->pUX, errorType, authenticationData->wzPackageOrContainerId, ERROR_ACCESS_DENIED, sczError, MB_RETRYTRYAGAIN, 0, NULL, &nResult); // ignore return value;
+    nResult = UserExperienceCheckExecuteResult(authenticationData->pUX, FALSE, MB_RETRYTRYAGAIN, nResult);
+    if (IDTRYAGAIN == nResult && authenticationData->pUX->hwndApply)
+    {
+        er = ::InternetErrorDlg(authenticationData->pUX->hwndApply, hUrl, ERROR_INTERNET_INCORRECT_PASSWORD, FLAGS_ERROR_UI_FILTER_FOR_ERRORS | FLAGS_ERROR_UI_FLAGS_CHANGE_OPTIONS | FLAGS_ERROR_UI_FLAGS_GENERATE_DATA, NULL);
+        if (ERROR_SUCCESS == er || ERROR_CANCELLED == er)
+        {
+            hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
+        }
+        else if (ERROR_INTERNET_FORCE_RETRY == er)
+        {
+            *pfRetrySend = TRUE;
+            hr = S_OK;
+        }
+        else
+        {
+            hr = HRESULT_FROM_WIN32(ERROR_ACCESS_DENIED);
+        }
+    }
+    else if (IDRETRY == nResult)
+    {
+        *pfRetry = TRUE;
+        hr = S_OK;
+    }
+    else
+    {
+        hr = HRESULT_FROM_WIN32(ERROR_ACCESS_DENIED);
+    }
+
+LExit:
+    ReleaseStr(sczError);
+
+    return hr;
+}
+
+static DWORD CALLBACK CacheProgressRoutine(
+    __in LARGE_INTEGER TotalFileSize,
+    __in LARGE_INTEGER TotalBytesTransferred,
+    __in LARGE_INTEGER /*StreamSize*/,
+    __in LARGE_INTEGER /*StreamBytesTransferred*/,
+    __in DWORD /*dwStreamNumber*/,
+    __in DWORD /*dwCallbackReason*/,
+    __in HANDLE /*hSourceFile*/,
+    __in HANDLE /*hDestinationFile*/,
+    __in_opt LPVOID lpData
+    )
+{
+    HRESULT hr = S_OK;
+    DWORD dwResult = PROGRESS_CONTINUE;
+    BURN_CACHE_ACQUIRE_PROGRESS_CONTEXT* pProgress = static_cast<BURN_CACHE_ACQUIRE_PROGRESS_CONTEXT*>(lpData);
+    LPCWSTR wzPackageOrContainerId = pProgress->pContainer ? pProgress->pContainer->sczId : pProgress->pPackage ? pProgress->pPackage->sczId : NULL;
+    LPCWSTR wzPayloadId = pProgress->pPayload ? pProgress->pPayload->sczKey : NULL;
+    DWORD64 qwCacheProgress = pProgress->qwCacheProgress + TotalBytesTransferred.QuadPart;
+    if (qwCacheProgress > pProgress->qwTotalCacheSize)
+    {
+        AssertSz(FALSE, "Apply has cached more than Plan envisioned.");
+        qwCacheProgress = pProgress->qwTotalCacheSize;
+    }
+    DWORD dwOverallPercentage = pProgress->qwTotalCacheSize ? static_cast<DWORD>(qwCacheProgress * 100 / pProgress->qwTotalCacheSize) : 0;
+
+    hr = UserExperienceOnCacheAcquireProgress(pProgress->pUX, wzPackageOrContainerId, wzPayloadId, TotalBytesTransferred.QuadPart, TotalFileSize.QuadPart, dwOverallPercentage);
+    if (HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT) == hr)
+    {
+        dwResult = PROGRESS_CANCEL;
+        pProgress->fCancel = TRUE;
+    }
+    else if (FAILED(hr))
+    {
+        dwResult = PROGRESS_CANCEL;
+        pProgress->fError = TRUE;
+    }
+    else
+    {
+        dwResult = PROGRESS_CONTINUE;
+    }
+
+    return dwResult;
+}
+
+static void DoRollbackCache(
+    __in BURN_USER_EXPERIENCE* /*pUX*/,
+    __in BURN_PLAN* pPlan,
+    __in HANDLE hPipe,
+    __in DWORD dwCheckpoint
+    )
+{
+    HRESULT hr = S_OK;
+    DWORD iCheckpoint = 0;
+
+    // Scan to last checkpoint.
+    for (DWORD i = 0; i < pPlan->cRollbackCacheActions; ++i)
+    {
+        BURN_CACHE_ACTION* pRollbackCacheAction = &pPlan->rgRollbackCacheActions[i];
+
+        if (BURN_CACHE_ACTION_TYPE_CHECKPOINT == pRollbackCacheAction->type && pRollbackCacheAction->checkpoint.dwId == dwCheckpoint)
+        {
+            iCheckpoint = i;
+            break;
+        }
+    }
+
+    // Rollback cache actions.
+    if (iCheckpoint)
+    {
+        // i has to be a signed integer so it doesn't get decremented to 0xFFFFFFFF.
+        for (int i = iCheckpoint - 1; i >= 0; --i)
+        {
+            BURN_CACHE_ACTION* pRollbackCacheAction = &pPlan->rgRollbackCacheActions[i];
+
+            switch (pRollbackCacheAction->type)
+            {
+            case BURN_CACHE_ACTION_TYPE_CHECKPOINT:
+                break;
+
+            case BURN_CACHE_ACTION_TYPE_ROLLBACK_PACKAGE:
+                hr = CleanPackage(hPipe, pRollbackCacheAction->rollbackPackage.pPackage);
+                break;
+
+            default:
+                AssertSz(FALSE, "Invalid rollback cache action.");
+                break;
+            }
+        }
+    }
+}
+
+/* MSI Transactions:
+ * All MSI/MSP/MSU packages wrapped in MsiBeginTranasaction-MsiEndTransaction pair are installed or uninstalled together.
+*/
+static HRESULT ExecuteMsiBeginTransaction(
+    __in BURN_EXECUTE_CONTEXT* pContext
+    , __in BURN_ENGINE_STATE* pEngineState
+)
+{
+    HRESULT hr = S_OK;
+    UINT uResult = ERROR_SUCCESS;
+
+    // Per user/machine context
+    if (pEngineState->plan.fPerMachine)
+    {
+        hr = ElevationMsiBeginTransaction(pEngineState->companionConnection.hPipe, pEngineState->userExperience.hwndApply, pContext);
+        ExitOnFailure(hr, "Failed to begin an MSI transaction.");
+    }
+    else
+    {
+        MSIHANDLE hMsiTrns = NULL;
+        HANDLE hMsiTrnsEvent = NULL;
+        uResult = MsiBeginTransaction(L"WiX", 0, &hMsiTrns, &hMsiTrnsEvent);
+        ExitOnWin32Error(uResult, hr, "Failed beginning an MSI transaction");
+    }
+
+LExit:
+    return hr;
+}
+
+static HRESULT ExecuteMsiCommitTransaction(
+    __in BURN_EXECUTE_CONTEXT* pContext
+    , __in BURN_ENGINE_STATE* pEngineState
+)
+{
+    HRESULT hr = S_OK;
+    UINT uResult = ERROR_SUCCESS;
+
+    // Per user/machine context
+    if (pEngineState->plan.fPerMachine)
+    {
+        hr = ElevationMsiCommitTransaction(pEngineState->companionConnection.hPipe, pEngineState->userExperience.hwndApply, pContext);
+        ExitOnFailure(hr, "Failed to commit an MSI transaction.");
+    }
+    else
+    {
+        uResult = MsiEndTransaction(MSITRANSACTIONSTATE_COMMIT);
+        ExitOnWin32Error(uResult, hr, "Failed beginning an MSI transaction");
+    }
+
+LExit:
+    return hr;
+}
+
+static HRESULT ExecuteMsiRollbackTransaction(
+    __in BURN_EXECUTE_CONTEXT* pContext
+    , __in BURN_ENGINE_STATE* pEngineState
+)
+{
+    HRESULT hr = S_OK;
+    UINT uResult = ERROR_SUCCESS;
+
+    // Per user/machine context
+    if (pEngineState->plan.fPerMachine)
+    {
+        hr = ElevationMsiRollbackTransaction(pEngineState->companionConnection.hPipe, pEngineState->userExperience.hwndApply, pContext);
+        ExitOnFailure(hr, "Failed to rollback an MSI transaction.");
+    }
+    else
+    {
+        uResult = MsiEndTransaction(MSITRANSACTIONSTATE_ROLLBACK);
+        ExitOnWin32Error(uResult, hr, "Failed beginning an MSI transaction");
+    }
+
+LExit:
+    return hr;
+}
+
+// Currently, supporting only elevated transactions.
+static HRESULT DoMsiBeginTransaction(
+    __in BURN_EXECUTE_CONTEXT *pContext
+    , __in BURN_ENGINE_STATE* pEngineState
+)
+{
+    HRESULT hr = S_OK;
+
+    hr = ExecuteMsiBeginTransaction(pContext, pEngineState);
+    ExitOnFailure(hr, "Failed to execute EXE package.");
+
+LExit:
+    return hr;
+}
+
+static HRESULT DoMsiCommitTransaction(
+    __in BURN_EXECUTE_CONTEXT *pContext
+    , __in BURN_ENGINE_STATE* pEngineState
+)
+{
+    HRESULT hr = S_OK;
+
+    hr = ExecuteMsiCommitTransaction(pContext, pEngineState);
+    ExitOnFailure(hr, "Failed to execute EXE package.");
+
+LExit:
+    return hr;
+}
+
+static HRESULT DoMsiRollbackTransaction(
+    __in BURN_EXECUTE_CONTEXT *pContext
+    , __in BURN_ENGINE_STATE* pEngineState
+)
+{
+    HRESULT hr = S_OK;
+
+    hr = ExecuteMsiRollbackTransaction(pContext, pEngineState);
+    ExitOnFailure(hr, "Failed to execute EXE package.");
+
+LExit:
+    return hr;
+}
+
+
+static HRESULT DoExecuteAction(
+    __in BURN_ENGINE_STATE* pEngineState,
+    __in BURN_EXECUTE_ACTION* pExecuteAction,
+    __in_opt HANDLE hCacheThread,
+    __in BURN_EXECUTE_CONTEXT* pContext,
+    __inout BURN_ROLLBACK_BOUNDARY** ppRollbackBoundary,
+    __out DWORD* pdwCheckpoint,
+    __out BOOL* pfKeepRegistration,
+    __out BOOL* pfSuspend,
+    __out BOOTSTRAPPER_APPLY_RESTART* pRestart
+    )
+{
+    Assert(!pExecuteAction->fDeleted);
+
+    HRESULT hr = S_OK;
+    HANDLE rghWait[2] = { };
+    BOOTSTRAPPER_APPLY_RESTART restart = BOOTSTRAPPER_APPLY_RESTART_NONE;
+    BOOL fRetry = FALSE;
+    BOOL fStopWusaService = FALSE;
+
+    pContext->fRollback = FALSE;
+
+    do
+    {
+        switch (pExecuteAction->type)
+        {
+        case BURN_EXECUTE_ACTION_TYPE_CHECKPOINT:
+            *pdwCheckpoint = pExecuteAction->checkpoint.dwId;
+            break;
+
+        case BURN_EXECUTE_ACTION_TYPE_WAIT_SYNCPOINT:
+            // wait for cache sync-point
+            rghWait[0] = pExecuteAction->syncpoint.hEvent;
+            rghWait[1] = hCacheThread;
+            switch (::WaitForMultipleObjects(rghWait[1] ? 2 : 1, rghWait, FALSE, INFINITE))
+            {
+            case WAIT_OBJECT_0:
+                break;
+
+            case WAIT_OBJECT_0 + 1:
+                if (!::GetExitCodeThread(hCacheThread, (DWORD*)&hr))
+                {
+                    ExitWithLastError(hr, "Failed to get cache thread exit code.");
+                }
+
+                if (SUCCEEDED(hr))
+                {
+                    hr = E_UNEXPECTED;
+                }
+                ExitOnFailure(hr, "Cache thread exited unexpectedly.");
+
+            case WAIT_FAILED: __fallthrough;
+            default:
+                ExitWithLastError(hr, "Failed to wait for cache check-point.");
+            }
+            break;
+
+        case BURN_EXECUTE_ACTION_TYPE_EXE_PACKAGE:
+            hr = ExecuteExePackage(pEngineState, pExecuteAction, pContext, FALSE, &fRetry, pfSuspend, &restart);
+            ExitOnFailure(hr, "Failed to execute EXE package.");
+            break;
+
+        case BURN_EXECUTE_ACTION_TYPE_MSI_PACKAGE:
+            hr = ExecuteMsiPackage(pEngineState, pExecuteAction, pContext, FALSE, &fRetry, pfSuspend, &restart);
+            ExitOnFailure(hr, "Failed to execute MSI package.");
+            break;
+
+        case BURN_EXECUTE_ACTION_TYPE_MSP_TARGET:
+            hr = ExecuteMspPackage(pEngineState, pExecuteAction, pContext, FALSE, &fRetry, pfSuspend, &restart);
+            ExitOnFailure(hr, "Failed to execute MSP package.");
+            break;
+
+        case BURN_EXECUTE_ACTION_TYPE_MSU_PACKAGE:
+            hr = ExecuteMsuPackage(pEngineState, pExecuteAction, pContext, FALSE, fStopWusaService, &fRetry, pfSuspend, &restart);
+            fStopWusaService = fRetry;
+            ExitOnFailure(hr, "Failed to execute MSU package.");
+            break;
+
+        case BURN_EXECUTE_ACTION_TYPE_PACKAGE_PROVIDER:
+            hr = ExecutePackageProviderAction(pEngineState, pExecuteAction, pContext);
+            ExitOnFailure(hr, "Failed to execute package provider registration action.");
+            break;
+
+        case BURN_EXECUTE_ACTION_TYPE_PACKAGE_DEPENDENCY:
+            hr = ExecuteDependencyAction(pEngineState, pExecuteAction, pContext);
+            ExitOnFailure(hr, "Failed to execute dependency action.");
+            break;
+
+        case BURN_EXECUTE_ACTION_TYPE_COMPATIBLE_PACKAGE:
+            hr = ExecuteCompatiblePackageAction(pEngineState, pExecuteAction);
+            ExitOnFailure(hr, "Failed to execute compatible package action.");
+            break;
+
+        case BURN_EXECUTE_ACTION_TYPE_REGISTRATION:
+            *pfKeepRegistration = pExecuteAction->registration.fKeep;
+            break;
+
+        case BURN_EXECUTE_ACTION_TYPE_ROLLBACK_BOUNDARY:
+            *ppRollbackBoundary = pExecuteAction->rollbackBoundary.pRollbackBoundary;
+            break;
+
+        case BURN_EXECUTE_ACTION_TYPE_SERVICE_STOP: __fallthrough;
+        case BURN_EXECUTE_ACTION_TYPE_SERVICE_START: __fallthrough;
+        default:
+            hr = E_UNEXPECTED;
+            ExitOnFailure(hr, "Invalid execute action.");
+        }
+
+        if (*pRestart < restart)
+        {
+            *pRestart = restart;
+        }
+    } while (fRetry && *pRestart < BOOTSTRAPPER_APPLY_RESTART_INITIATED);
+
+LExit:
+    return hr;
+}
+
+static HRESULT DoRollbackActions(
+    __in BURN_ENGINE_STATE* pEngineState,
+    __in BURN_EXECUTE_CONTEXT* pContext,
+    __in DWORD dwCheckpoint,
+    __in BOOL fInTransaction,
+    __out BOOL* pfKeepRegistration,
+    __out BOOTSTRAPPER_APPLY_RESTART* pRestart
+)
+{
+    HRESULT hr = S_OK;
+    DWORD iCheckpoint = 0;
+    BOOL fRetryIgnored = FALSE;
+    BOOL fSuspendIgnored = FALSE;
+
+    pContext->fRollback = TRUE;
+
+    // Rollback MSI transaction
+    if (fInTransaction)
+    {
+        hr = DoMsiRollbackTransaction(pContext, pEngineState);
+        ExitOnFailure(hr, "Failed rolling back transaction");
+    }
+
+    // scan to last checkpoint
+    for (DWORD i = 0; i < pEngineState->plan.cRollbackActions; ++i)
+    {
+        BURN_EXECUTE_ACTION* pRollbackAction = &pEngineState->plan.rgRollbackActions[i];
+        if (pRollbackAction->fDeleted)
+        {
+            continue;
+        }
+
+        if (BURN_EXECUTE_ACTION_TYPE_CHECKPOINT == pRollbackAction->type)
+        {
+            if (pRollbackAction->checkpoint.dwId == dwCheckpoint)
+            {
+                iCheckpoint = i;
+                break;
+            }
+        }
+    }
+
+    // execute rollback actions
+    if (iCheckpoint)
+    {
+        // i has to be a signed integer so it doesn't get decremented to 0xFFFFFFFF.
+        for (int i = iCheckpoint - 1; i >= 0; --i)
+        {
+            BURN_EXECUTE_ACTION* pRollbackAction = &pEngineState->plan.rgRollbackActions[i];
+            if (pRollbackAction->fDeleted)
+            {
+                continue;
+            }
+
+            BOOTSTRAPPER_APPLY_RESTART restart = BOOTSTRAPPER_APPLY_RESTART_NONE;
+            switch (pRollbackAction->type)
+            {
+            case BURN_EXECUTE_ACTION_TYPE_CHECKPOINT:
+                break;
+
+            case BURN_EXECUTE_ACTION_TYPE_EXE_PACKAGE:
+                hr = ExecuteExePackage(pEngineState, pRollbackAction, pContext, TRUE, &fRetryIgnored, &fSuspendIgnored, &restart);
+                TraceError(hr, "Failed to rollback EXE package.");
+                hr = S_OK;
+                break;
+
+            case BURN_EXECUTE_ACTION_TYPE_MSI_PACKAGE:
+                if (fInTransaction)
+                {
+                    LogString(REPORT_STANDARD, "Skipping rolling back an MSI package- already done in transaction rollback\n");
+                    break;
+                }
+                hr = ExecuteMsiPackage(pEngineState, pRollbackAction, pContext, TRUE, &fRetryIgnored, &fSuspendIgnored, &restart);
+                TraceError(hr, "Failed to rollback MSI package.");
+                hr = S_OK;
+                break;
+
+            case BURN_EXECUTE_ACTION_TYPE_MSP_TARGET:
+                if (fInTransaction)
+                {
+                    LogString(REPORT_STANDARD, "Skipping rolling back an MSP package- already done in transaction rollback\n");
+                    break;
+                }
+                hr = ExecuteMspPackage(pEngineState, pRollbackAction, pContext, TRUE, &fRetryIgnored, &fSuspendIgnored, &restart);
+                TraceError(hr, "Failed to rollback MSP package.");
+                hr = S_OK;
+                break;
+
+            case BURN_EXECUTE_ACTION_TYPE_MSU_PACKAGE:
+                if (fInTransaction)
+                {
+                    LogString(REPORT_STANDARD, "Skipping rolling back an MSU package- already done in transaction rollback\n");
+                    break;
+                }
+                hr = ExecuteMsuPackage(pEngineState, pRollbackAction, pContext, TRUE, FALSE, &fRetryIgnored, &fSuspendIgnored, &restart);
+                TraceError(hr, "Failed to rollback MSU package.");
+                hr = S_OK;
+                break;
+
+            case BURN_EXECUTE_ACTION_TYPE_PACKAGE_PROVIDER:
+                hr = ExecutePackageProviderAction(pEngineState, pRollbackAction, pContext);
+                TraceError(hr, "Failed to rollback package provider action.");
+                hr = S_OK;
+                break;
+
+            case BURN_EXECUTE_ACTION_TYPE_PACKAGE_DEPENDENCY:
+                hr = ExecuteDependencyAction(pEngineState, pRollbackAction, pContext);
+                TraceError(hr, "Failed to rollback dependency action.");
+                hr = S_OK;
+                break;
+
+            case BURN_EXECUTE_ACTION_TYPE_REGISTRATION:
+                *pfKeepRegistration = pRollbackAction->registration.fKeep;
+                break;
+
+            case BURN_EXECUTE_ACTION_TYPE_ROLLBACK_BOUNDARY:
+                ExitFunction1(hr = S_OK);
+
+            case BURN_EXECUTE_ACTION_TYPE_UNCACHE_PACKAGE:
+                hr = CleanPackage(pEngineState->companionConnection.hPipe, pRollbackAction->uncachePackage.pPackage);
+                break;
+
+            case BURN_EXECUTE_ACTION_TYPE_SERVICE_STOP: __fallthrough;
+            case BURN_EXECUTE_ACTION_TYPE_SERVICE_START: __fallthrough;
+            default:
+                hr = E_UNEXPECTED;
+                ExitOnFailure(hr, "Invalid rollback action: %d.", pRollbackAction->type);
+            }
+
+            if (*pRestart < restart)
+            {
+                *pRestart = restart;
+            }
+        }
+    }
+
+LExit:
+    return hr;
+}
+
+static HRESULT ExecuteExePackage(
+    __in BURN_ENGINE_STATE* pEngineState,
+    __in BURN_EXECUTE_ACTION* pExecuteAction,
+    __in BURN_EXECUTE_CONTEXT* pContext,
+    __in BOOL fRollback,
+    __out BOOL* pfRetry,
+    __out BOOL* pfSuspend,
+    __out BOOTSTRAPPER_APPLY_RESTART* pRestart
+    )
+{
+    HRESULT hr = S_OK;
+    HRESULT hrExecute = S_OK;
+    GENERIC_EXECUTE_MESSAGE message = { };
+    int nResult = 0;
+    BOOL fBeginCalled = FALSE;
+
+    if (FAILED(pExecuteAction->exePackage.pPackage->hrCacheResult))
+    {
+        LogId(REPORT_STANDARD, MSG_APPLY_SKIPPED_FAILED_CACHED_PACKAGE, pExecuteAction->exePackage.pPackage->sczId, pExecuteAction->exePackage.pPackage->hrCacheResult);
+        ExitFunction1(hr = S_OK);
+    }
+
+    Assert(pContext->fRollback == fRollback);
+    pContext->pExecutingPackage = pExecuteAction->exePackage.pPackage;
+    fBeginCalled = TRUE;
+
+    // Send package execute begin to BA.
+    hr = UserExperienceOnExecutePackageBegin(&pEngineState->userExperience, pExecuteAction->exePackage.pPackage->sczId, !fRollback);
+    ExitOnRootFailure(hr, "BA aborted execute EXE package begin.");
+
+    message.type = GENERIC_EXECUTE_MESSAGE_PROGRESS;
+    message.dwAllowedResults = MB_OKCANCEL;
+    message.progress.dwPercentage = fRollback ? 100 : 0;
+    nResult = GenericExecuteMessageHandler(&message, pContext);
+    hr = UserExperienceInterpretExecuteResult(&pEngineState->userExperience, fRollback, message.dwAllowedResults, nResult);
+    ExitOnRootFailure(hr, "UX aborted EXE progress.");
+
+    // Execute package.
+    if (pExecuteAction->exePackage.pPackage->fPerMachine)
+    {
+        hrExecute = ElevationExecuteExePackage(pEngineState->companionConnection.hPipe, pExecuteAction, &pEngineState->variables, fRollback, GenericExecuteMessageHandler, pContext, pRestart);
+        ExitOnFailure(hrExecute, "Failed to configure per-machine EXE package.");
+    }
+    else
+    {
+        hrExecute = ExeEngineExecutePackage(pExecuteAction, &pEngineState->variables, fRollback, GenericExecuteMessageHandler, pContext, pRestart);
+        ExitOnFailure(hrExecute, "Failed to configure per-user EXE package.");
+    }
+
+    message.type = GENERIC_EXECUTE_MESSAGE_PROGRESS;
+    message.dwAllowedResults = MB_OKCANCEL;
+    message.progress.dwPercentage = fRollback ? 0 : 100;
+    nResult = GenericExecuteMessageHandler(&message, pContext);
+    hr = UserExperienceInterpretExecuteResult(&pEngineState->userExperience, fRollback, message.dwAllowedResults, nResult);
+    ExitOnRootFailure(hr, "UX aborted EXE progress.");
+
+    pContext->cExecutedPackages += fRollback ? -1 : 1;
+    (*pContext->pcOverallProgressTicks) += fRollback ? -1 : 1;
+
+    hr = ReportOverallProgressTicks(&pEngineState->userExperience, fRollback, pEngineState->plan.cOverallProgressTicksTotal, *pContext->pcOverallProgressTicks);
+    ExitOnRootFailure(hr, "UX aborted EXE package execute progress.");
+
+LExit:
+    if (fBeginCalled)
+    {
+        hr = ExecutePackageComplete(&pEngineState->userExperience, &pEngineState->variables, pExecuteAction->exePackage.pPackage, hr, hrExecute, fRollback, pRestart, pfRetry, pfSuspend);
+    }
+
+    return hr;
+}
+
+static HRESULT ExecuteMsiPackage(
+    __in BURN_ENGINE_STATE* pEngineState,
+    __in BURN_EXECUTE_ACTION* pExecuteAction,
+    __in BURN_EXECUTE_CONTEXT* pContext,
+    __in BOOL fRollback,
+    __out BOOL* pfRetry,
+    __out BOOL* pfSuspend,
+    __out BOOTSTRAPPER_APPLY_RESTART* pRestart
+    )
+{
+    HRESULT hr = S_OK;
+    HRESULT hrExecute = S_OK;
+    BOOL fBeginCalled = FALSE;
+
+    if (FAILED(pExecuteAction->msiPackage.pPackage->hrCacheResult))
+    {
+        LogId(REPORT_STANDARD, MSG_APPLY_SKIPPED_FAILED_CACHED_PACKAGE, pExecuteAction->msiPackage.pPackage->sczId, pExecuteAction->msiPackage.pPackage->hrCacheResult);
+        ExitFunction1(hr = S_OK);
+    }
+
+    Assert(pContext->fRollback == fRollback);
+    pContext->pExecutingPackage = pExecuteAction->msiPackage.pPackage;
+    fBeginCalled = TRUE;
+
+    // Send package execute begin to BA.
+    hr = UserExperienceOnExecutePackageBegin(&pEngineState->userExperience, pExecuteAction->msiPackage.pPackage->sczId, !fRollback);
+    ExitOnRootFailure(hr, "BA aborted execute MSI package begin.");
+
+    // execute package
+    if (pExecuteAction->msiPackage.pPackage->fPerMachine)
+    {
+        hrExecute = ElevationExecuteMsiPackage(pEngineState->companionConnection.hPipe, pEngineState->userExperience.hwndApply, pExecuteAction, &pEngineState->variables, fRollback, MsiExecuteMessageHandler, pContext, pRestart);
+        ExitOnFailure(hrExecute, "Failed to configure per-machine MSI package.");
+    }
+    else
+    {
+        hrExecute = MsiEngineExecutePackage(pEngineState->userExperience.hwndApply, pExecuteAction, &pEngineState->variables, fRollback, MsiExecuteMessageHandler, pContext, pRestart);
+        ExitOnFailure(hrExecute, "Failed to configure per-user MSI package.");
+    }
+
+    pContext->cExecutedPackages += fRollback ? -1 : 1;
+    (*pContext->pcOverallProgressTicks) += fRollback ? -1 : 1;
+
+    hr = ReportOverallProgressTicks(&pEngineState->userExperience, fRollback, pEngineState->plan.cOverallProgressTicksTotal, *pContext->pcOverallProgressTicks);
+    ExitOnRootFailure(hr, "UX aborted MSI package execute progress.");
+
+LExit:
+    if (fBeginCalled)
+    {
+        hr = ExecutePackageComplete(&pEngineState->userExperience, &pEngineState->variables, pExecuteAction->msiPackage.pPackage, hr, hrExecute, fRollback, pRestart, pfRetry, pfSuspend);
+    }
+
+    return hr;
+}
+
+static HRESULT ExecuteMspPackage(
+    __in BURN_ENGINE_STATE* pEngineState,
+    __in BURN_EXECUTE_ACTION* pExecuteAction,
+    __in BURN_EXECUTE_CONTEXT* pContext,
+    __in BOOL fRollback,
+    __out BOOL* pfRetry,
+    __out BOOL* pfSuspend,
+    __out BOOTSTRAPPER_APPLY_RESTART* pRestart
+    )
+{
+    HRESULT hr = S_OK;
+    HRESULT hrExecute = S_OK;
+    BOOL fBeginCalled = FALSE;
+
+    if (FAILED(pExecuteAction->mspTarget.pPackage->hrCacheResult))
+    {
+        LogId(REPORT_STANDARD, MSG_APPLY_SKIPPED_FAILED_CACHED_PACKAGE, pExecuteAction->mspTarget.pPackage->sczId, pExecuteAction->mspTarget.pPackage->hrCacheResult);
+        ExitFunction1(hr = S_OK);
+    }
+
+    Assert(pContext->fRollback == fRollback);
+    pContext->pExecutingPackage = pExecuteAction->mspTarget.pPackage;
+    fBeginCalled = TRUE;
+
+    // Send package execute begin to BA.
+    hr = UserExperienceOnExecutePackageBegin(&pEngineState->userExperience, pExecuteAction->mspTarget.pPackage->sczId, !fRollback);
+    ExitOnRootFailure(hr, "BA aborted execute MSP package begin.");
+
+    // Now send all the patches that target this product code.
+    for (DWORD i = 0; i < pExecuteAction->mspTarget.cOrderedPatches; ++i)
+    {
+        BURN_PACKAGE* pMspPackage = pExecuteAction->mspTarget.rgOrderedPatches[i].pPackage;
+
+        hr = UserExperienceOnExecutePatchTarget(&pEngineState->userExperience, pMspPackage->sczId, pExecuteAction->mspTarget.sczTargetProductCode);
+        ExitOnRootFailure(hr, "BA aborted execute MSP target.");
+    }
+
+    // execute package
+    if (pExecuteAction->mspTarget.fPerMachineTarget)
+    {
+        hrExecute = ElevationExecuteMspPackage(pEngineState->companionConnection.hPipe, pEngineState->userExperience.hwndApply, pExecuteAction, &pEngineState->variables, fRollback, MsiExecuteMessageHandler, pContext, pRestart);
+        ExitOnFailure(hrExecute, "Failed to configure per-machine MSP package.");
+    }
+    else
+    {
+        hrExecute = MspEngineExecutePackage(pEngineState->userExperience.hwndApply, pExecuteAction, &pEngineState->variables, fRollback, MsiExecuteMessageHandler, pContext, pRestart);
+        ExitOnFailure(hrExecute, "Failed to configure per-user MSP package.");
+    }
+
+    pContext->cExecutedPackages += fRollback ? -1 : 1;
+    (*pContext->pcOverallProgressTicks) += fRollback ? -1 : 1;
+
+    hr = ReportOverallProgressTicks(&pEngineState->userExperience, fRollback, pEngineState->plan.cOverallProgressTicksTotal, *pContext->pcOverallProgressTicks);
+    ExitOnRootFailure(hr, "UX aborted MSP package execute progress.");
+
+LExit:
+    if (fBeginCalled)
+    {
+        hr = ExecutePackageComplete(&pEngineState->userExperience, &pEngineState->variables, pExecuteAction->mspTarget.pPackage, hr, hrExecute, fRollback, pRestart, pfRetry, pfSuspend);
+    }
+
+    return hr;
+}
+
+static HRESULT ExecuteMsuPackage(
+    __in BURN_ENGINE_STATE* pEngineState,
+    __in BURN_EXECUTE_ACTION* pExecuteAction,
+    __in BURN_EXECUTE_CONTEXT* pContext,
+    __in BOOL fRollback,
+    __in BOOL fStopWusaService,
+    __out BOOL* pfRetry,
+    __out BOOL* pfSuspend,
+    __out BOOTSTRAPPER_APPLY_RESTART* pRestart
+    )
+{
+    HRESULT hr = S_OK;
+    HRESULT hrExecute = S_OK;
+    GENERIC_EXECUTE_MESSAGE message = { };
+    int nResult = 0;
+    BOOL fBeginCalled = FALSE;
+
+    if (FAILED(pExecuteAction->msuPackage.pPackage->hrCacheResult))
+    {
+        LogId(REPORT_STANDARD, MSG_APPLY_SKIPPED_FAILED_CACHED_PACKAGE, pExecuteAction->msuPackage.pPackage->sczId, pExecuteAction->msuPackage.pPackage->hrCacheResult);
+        ExitFunction1(hr = S_OK);
+    }
+
+    Assert(pContext->fRollback == fRollback);
+    pContext->pExecutingPackage = pExecuteAction->msuPackage.pPackage;
+    fBeginCalled = TRUE;
+
+    // Send package execute begin to BA.
+    hr = UserExperienceOnExecutePackageBegin(&pEngineState->userExperience, pExecuteAction->msuPackage.pPackage->sczId, !fRollback);
+    ExitOnRootFailure(hr, "BA aborted execute MSU package begin.");
+
+    message.type = GENERIC_EXECUTE_MESSAGE_PROGRESS;
+    message.dwAllowedResults = MB_OKCANCEL;
+    message.progress.dwPercentage = fRollback ? 100 : 0;
+    nResult = GenericExecuteMessageHandler(&message, pContext);
+    hr = UserExperienceInterpretExecuteResult(&pEngineState->userExperience, fRollback, message.dwAllowedResults, nResult);
+    ExitOnRootFailure(hr, "UX aborted MSU progress.");
+
+    // execute package
+    if (pExecuteAction->msuPackage.pPackage->fPerMachine)
+    {
+        hrExecute = ElevationExecuteMsuPackage(pEngineState->companionConnection.hPipe, pExecuteAction, fRollback, fStopWusaService, GenericExecuteMessageHandler, pContext, pRestart);
+        ExitOnFailure(hrExecute, "Failed to configure per-machine MSU package.");
+    }
+    else
+    {
+        hrExecute = E_UNEXPECTED;
+        ExitOnFailure(hr, "MSU packages cannot be per-user.");
+    }
+
+    message.type = GENERIC_EXECUTE_MESSAGE_PROGRESS;
+    message.dwAllowedResults = MB_OKCANCEL;
+    message.progress.dwPercentage = fRollback ? 0 : 100;
+    nResult = GenericExecuteMessageHandler(&message, pContext);
+    hr = UserExperienceInterpretExecuteResult(&pEngineState->userExperience, fRollback, message.dwAllowedResults, nResult);
+    ExitOnRootFailure(hr, "UX aborted MSU progress.");
+
+    pContext->cExecutedPackages += fRollback ? -1 : 1;
+    (*pContext->pcOverallProgressTicks) += fRollback ? -1 : 1;
+
+    hr = ReportOverallProgressTicks(&pEngineState->userExperience, fRollback, pEngineState->plan.cOverallProgressTicksTotal, *pContext->pcOverallProgressTicks);
+    ExitOnRootFailure(hr, "UX aborted MSU package execute progress.");
+
+LExit:
+    if (fBeginCalled)
+    {
+        hr = ExecutePackageComplete(&pEngineState->userExperience, &pEngineState->variables, pExecuteAction->msuPackage.pPackage, hr, hrExecute, fRollback, pRestart, pfRetry, pfSuspend);
+    }
+
+    return hr;
+}
+
+static HRESULT ExecutePackageProviderAction(
+    __in BURN_ENGINE_STATE* pEngineState,
+    __in BURN_EXECUTE_ACTION* pAction,
+    __in BURN_EXECUTE_CONTEXT* /*pContext*/
+    )
+{
+    HRESULT hr = S_OK;
+
+    if (pAction->packageProvider.pPackage->fPerMachine)
+    {
+        hr = ElevationExecutePackageProviderAction(pEngineState->companionConnection.hPipe, pAction);
+        ExitOnFailure(hr, "Failed to register the package provider on per-machine package.");
+    }
+    else
+    {
+        hr = DependencyExecutePackageProviderAction(pAction);
+        ExitOnFailure(hr, "Failed to register the package provider on per-user package.");
+    }
+
+LExit:
+    return hr;
+}
+
+static HRESULT ExecuteDependencyAction(
+    __in BURN_ENGINE_STATE* pEngineState,
+    __in BURN_EXECUTE_ACTION* pAction,
+    __in BURN_EXECUTE_CONTEXT* /*pContext*/
+    )
+{
+    HRESULT hr = S_OK;
+
+    if (pAction->packageDependency.pPackage->fPerMachine)
+    {
+        hr = ElevationExecutePackageDependencyAction(pEngineState->companionConnection.hPipe, pAction);
+        ExitOnFailure(hr, "Failed to register the dependency on per-machine package.");
+    }
+    else
+    {
+        hr = DependencyExecutePackageDependencyAction(FALSE, pAction);
+        ExitOnFailure(hr, "Failed to register the dependency on per-user package.");
+    }
+
+LExit:
+    return hr;
+}
+
+static HRESULT ExecuteCompatiblePackageAction(
+    __in BURN_ENGINE_STATE* pEngineState,
+    __in BURN_EXECUTE_ACTION* pAction
+    )
+{
+    HRESULT hr = S_OK;
+
+    if (pAction->compatiblePackage.pReferencePackage->fPerMachine)
+    {
+        hr = ElevationLoadCompatiblePackageAction(pEngineState->companionConnection.hPipe, pAction);
+        ExitOnFailure(hr, "Failed to load compatible package on per-machine package.");
+    }
+
+    // Compatible package already loaded in this process.
+
+LExit:
+    return hr;
+}
+
+static HRESULT CleanPackage(
+    __in HANDLE hElevatedPipe,
+    __in BURN_PACKAGE* pPackage
+    )
+{
+    HRESULT hr = S_OK;
+
+    if (pPackage->fPerMachine)
+    {
+        hr = ElevationCleanPackage(hElevatedPipe, pPackage);
+    }
+    else
+    {
+        hr = CacheRemovePackage(FALSE, pPackage->sczId, pPackage->sczCacheId);
+    }
+
+    return hr;
+}
+
+static int GenericExecuteMessageHandler(
+    __in GENERIC_EXECUTE_MESSAGE* pMessage,
+    __in LPVOID pvContext
+    )
+{
+    BURN_EXECUTE_CONTEXT* pContext = (BURN_EXECUTE_CONTEXT*)pvContext;
+    int nResult = IDNOACTION;
+
+    switch (pMessage->type)
+    {
+    case GENERIC_EXECUTE_MESSAGE_PROGRESS:
+        {
+            DWORD dwOverallProgress = pContext->cExecutePackagesTotal ? (pContext->cExecutedPackages * 100 + pMessage->progress.dwPercentage) / (pContext->cExecutePackagesTotal) : 0;
+            UserExperienceOnExecuteProgress(pContext->pUX, pContext->pExecutingPackage->sczId, pMessage->progress.dwPercentage, dwOverallProgress, &nResult); // ignore return value.
+        }
+        break;
+
+    case GENERIC_EXECUTE_MESSAGE_ERROR:
+        UserExperienceOnError(pContext->pUX, BOOTSTRAPPER_ERROR_TYPE_EXE_PACKAGE, pContext->pExecutingPackage->sczId, pMessage->error.dwErrorCode, pMessage->error.wzMessage, pMessage->dwAllowedResults, 0, NULL, &nResult); // ignore return value.
+        break;
+
+    case GENERIC_EXECUTE_MESSAGE_FILES_IN_USE:
+        UserExperienceOnExecuteFilesInUse(pContext->pUX, pContext->pExecutingPackage->sczId, pMessage->filesInUse.cFiles, pMessage->filesInUse.rgwzFiles, &nResult); // ignore return value.
+        break;
+    }
+
+    nResult = UserExperienceCheckExecuteResult(pContext->pUX, pContext->fRollback, pMessage->dwAllowedResults, nResult);
+    return nResult;
+}
+
+static int MsiExecuteMessageHandler(
+    __in WIU_MSI_EXECUTE_MESSAGE* pMessage,
+    __in_opt LPVOID pvContext
+    )
+{
+    BURN_EXECUTE_CONTEXT* pContext = (BURN_EXECUTE_CONTEXT*)pvContext;
+    int nResult = IDNOACTION;
+
+    switch (pMessage->type)
+    {
+    case WIU_MSI_EXECUTE_MESSAGE_PROGRESS:
+        {
+        DWORD dwOverallProgress = pContext->cExecutePackagesTotal ? (pContext->cExecutedPackages * 100 + pMessage->progress.dwPercentage) / (pContext->cExecutePackagesTotal) : 0;
+        UserExperienceOnExecuteProgress(pContext->pUX, pContext->pExecutingPackage->sczId, pMessage->progress.dwPercentage, dwOverallProgress, &nResult); // ignore return value.
+        }
+        break;
+
+    case WIU_MSI_EXECUTE_MESSAGE_ERROR:
+        nResult = pMessage->nResultRecommendation;
+        UserExperienceOnError(pContext->pUX, BOOTSTRAPPER_ERROR_TYPE_WINDOWS_INSTALLER, pContext->pExecutingPackage->sczId, pMessage->error.dwErrorCode, pMessage->error.wzMessage, pMessage->dwAllowedResults, pMessage->cData, pMessage->rgwzData, &nResult); // ignore return value.
+        break;
+
+    case WIU_MSI_EXECUTE_MESSAGE_MSI_MESSAGE:
+        nResult = pMessage->nResultRecommendation;
+        UserExperienceOnExecuteMsiMessage(pContext->pUX, pContext->pExecutingPackage->sczId, pMessage->msiMessage.mt, pMessage->dwAllowedResults, pMessage->msiMessage.wzMessage, pMessage->cData, pMessage->rgwzData, &nResult); // ignore return value.
+        break;
+
+    case WIU_MSI_EXECUTE_MESSAGE_MSI_FILES_IN_USE:
+        UserExperienceOnExecuteFilesInUse(pContext->pUX, pContext->pExecutingPackage->sczId, pMessage->msiFilesInUse.cFiles, pMessage->msiFilesInUse.rgwzFiles, &nResult); // ignore return value.
+        break;
+    }
+
+    nResult = UserExperienceCheckExecuteResult(pContext->pUX, pContext->fRollback, pMessage->dwAllowedResults, nResult);
+    return nResult;
+}
+
+static HRESULT ReportOverallProgressTicks(
+    __in BURN_USER_EXPERIENCE* pUX,
+    __in BOOL fRollback,
+    __in DWORD cOverallProgressTicksTotal,
+    __in DWORD cOverallProgressTicks
+    )
+{
+    HRESULT hr = S_OK;
+    DWORD dwProgress = cOverallProgressTicksTotal ? (cOverallProgressTicks * 100 / cOverallProgressTicksTotal) : 0;
+
+    // TODO: consider sending different progress numbers in the future.
+    hr = UserExperienceOnProgress(pUX, fRollback, dwProgress, dwProgress);
+
+    return hr;
+}
+
+static HRESULT ExecutePackageComplete(
+    __in BURN_USER_EXPERIENCE* pUX,
+    __in BURN_VARIABLES* pVariables,
+    __in BURN_PACKAGE* pPackage,
+    __in HRESULT hrOverall,
+    __in HRESULT hrExecute,
+    __in BOOL fRollback,
+    __out BOOTSTRAPPER_APPLY_RESTART* pRestart,
+    __out BOOL* pfRetry,
+    __out BOOL* pfSuspend
+    )
+{
+    HRESULT hr = FAILED(hrOverall) ? hrOverall : hrExecute; // if the overall function failed use that otherwise use the execution result.
+    BOOTSTRAPPER_EXECUTEPACKAGECOMPLETE_ACTION executePackageCompleteAction = FAILED(hrOverall) || SUCCEEDED(hrExecute) || pPackage->fVital ? BOOTSTRAPPER_EXECUTEPACKAGECOMPLETE_ACTION_NONE : BOOTSTRAPPER_EXECUTEPACKAGECOMPLETE_ACTION_IGNORE;
+
+    // Send package execute complete to BA.
+    UserExperienceOnExecutePackageComplete(pUX, pPackage->sczId, hr, *pRestart, &executePackageCompleteAction);
+    if (BOOTSTRAPPER_EXECUTEPACKAGECOMPLETE_ACTION_RESTART == executePackageCompleteAction)
+    {
+        *pRestart = BOOTSTRAPPER_APPLY_RESTART_INITIATED;
+    }
+    *pfRetry = (FAILED(hrExecute) && BOOTSTRAPPER_EXECUTEPACKAGECOMPLETE_ACTION_RETRY == executePackageCompleteAction); // allow retry only on failures.
+    *pfSuspend = (BOOTSTRAPPER_EXECUTEPACKAGECOMPLETE_ACTION_SUSPEND == executePackageCompleteAction);
+
+    // Remember this package as the package that initiated the forced restart.
+    if (BOOTSTRAPPER_APPLY_RESTART_INITIATED == *pRestart)
+    {
+        // Best effort to set the forced restart package variable.
+        VariableSetString(pVariables, BURN_BUNDLE_FORCED_RESTART_PACKAGE, pPackage->sczId, TRUE);
+    }
+
+    // If we're retrying, leave a message in the log file and say everything is okay.
+    if (*pfRetry)
+    {
+        LogId(REPORT_STANDARD, MSG_APPLY_RETRYING_PACKAGE, pPackage->sczId, hrExecute);
+        hr = S_OK;
+    }
+    else if (SUCCEEDED(hrOverall) && FAILED(hrExecute) && BOOTSTRAPPER_EXECUTEPACKAGECOMPLETE_ACTION_IGNORE == executePackageCompleteAction && !pPackage->fVital) // If we *only* failed to execute and the BA ignored this *not-vital* package, say everything is okay.
+    {
+        LogId(REPORT_STANDARD, MSG_APPLY_CONTINUING_NONVITAL_PACKAGE, pPackage->sczId, hrExecute);
+        hr = S_OK;
+    }
+    else
+    {
+        LogId(REPORT_STANDARD, MSG_APPLY_COMPLETED_PACKAGE, LoggingRollbackOrExecute(fRollback), pPackage->sczId, hr, LoggingRestartToString(*pRestart));
+    }
+
+    return hr;
+}
diff --git a/src/engine/apply.h b/src/engine/apply.h
new file mode 100644
index 00000000..b717251e
--- /dev/null
+++ b/src/engine/apply.h
@@ -0,0 +1,106 @@
+#pragma once
+// 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.
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+enum GENERIC_EXECUTE_MESSAGE_TYPE
+{
+    GENERIC_EXECUTE_MESSAGE_NONE,
+    GENERIC_EXECUTE_MESSAGE_ERROR,
+    GENERIC_EXECUTE_MESSAGE_PROGRESS,
+    GENERIC_EXECUTE_MESSAGE_FILES_IN_USE,
+};
+
+typedef struct _APPLY_AUTHENTICATION_REQUIRED_DATA
+{
+    BURN_USER_EXPERIENCE* pUX;
+    LPCWSTR wzPackageOrContainerId;
+    LPCWSTR wzPayloadId;
+} APPLY_AUTHENTICATION_REQUIRED_DATA;
+
+typedef struct _GENERIC_EXECUTE_MESSAGE
+{
+    GENERIC_EXECUTE_MESSAGE_TYPE type;
+    DWORD dwAllowedResults;
+
+    union
+    {
+        struct
+        {
+            DWORD dwErrorCode;
+            LPCWSTR wzMessage;
+        } error;
+        struct
+        {
+            DWORD dwPercentage;
+        } progress;
+        struct
+        {
+            DWORD cFiles;
+            LPCWSTR* rgwzFiles;
+        } filesInUse;
+    };
+} GENERIC_EXECUTE_MESSAGE;
+
+
+typedef int (*PFN_GENERICMESSAGEHANDLER)(
+    __in GENERIC_EXECUTE_MESSAGE* pMessage,
+    __in LPVOID pvContext
+    );
+
+
+void ApplyInitialize();
+void ApplyUninitialize();
+HRESULT ApplySetVariables(
+    __in BURN_VARIABLES* pVariables
+    );
+void ApplyReset(
+    __in BURN_USER_EXPERIENCE* pUX,
+    __in BURN_PACKAGES* pPackages
+    );
+HRESULT ApplyLock(
+    __in BOOL fPerMachine,
+    __out HANDLE* phLock
+    );
+HRESULT ApplyRegister(
+    __in BURN_ENGINE_STATE* pEngineState
+    );
+HRESULT ApplyUnregister(
+    __in BURN_ENGINE_STATE* pEngineState,
+    __in BOOL fFailedOrRollback,
+    __in BOOL fRollback,
+    __in BOOL fSuspend,
+    __in BOOTSTRAPPER_APPLY_RESTART restart
+    );
+HRESULT ApplyCache(
+    __in HANDLE hSourceEngineFile,
+    __in BURN_USER_EXPERIENCE* pUX,
+    __in BURN_VARIABLES* pVariables,
+    __in BURN_PLAN* pPlan,
+    __in HANDLE hPipe,
+    __inout DWORD* pcOverallProgressTicks,
+    __out BOOL* pfRollback
+    );
+HRESULT ApplyExecute(
+    __in BURN_ENGINE_STATE* pEngineState,
+    __in_opt HANDLE hCacheThread,
+    __inout DWORD* pcOverallProgressTicks,
+    __out BOOL* pfKeepRegistration,
+    __out BOOL* pfRollback,
+    __out BOOL* pfSuspend,
+    __out BOOTSTRAPPER_APPLY_RESTART* pRestart
+    );
+void ApplyClean(
+    __in BURN_USER_EXPERIENCE* pUX,
+    __in BURN_PLAN* pPlan,
+    __in HANDLE hPipe
+    );
+
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/engine/approvedexe.cpp b/src/engine/approvedexe.cpp
new file mode 100644
index 00000000..55518519
--- /dev/null
+++ b/src/engine/approvedexe.cpp
@@ -0,0 +1,262 @@
+// 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.
+
+#include "precomp.h"
+
+
+// function definitions
+
+extern "C" HRESULT ApprovedExesParseFromXml(
+    __in BURN_APPROVED_EXES* pApprovedExes,
+    __in IXMLDOMNode* pixnBundle
+    )
+{
+    HRESULT hr = S_OK;
+    IXMLDOMNodeList* pixnNodes = NULL;
+    IXMLDOMNode* pixnNode = NULL;
+    DWORD cNodes = 0;
+    LPWSTR scz = NULL;
+
+    // select approved exe nodes
+    hr = XmlSelectNodes(pixnBundle, L"ApprovedExeForElevation", &pixnNodes);
+    ExitOnFailure(hr, "Failed to select approved exe nodes.");
+
+    // get approved exe node count
+    hr = pixnNodes->get_length((long*)&cNodes);
+    ExitOnFailure(hr, "Failed to get approved exe node count.");
+
+    if (!cNodes)
+    {
+        ExitFunction();
+    }
+
+    // allocate memory for approved exes
+    pApprovedExes->rgApprovedExes = (BURN_APPROVED_EXE*)MemAlloc(sizeof(BURN_APPROVED_EXE) * cNodes, TRUE);
+    ExitOnNull(pApprovedExes->rgApprovedExes, hr, E_OUTOFMEMORY, "Failed to allocate memory for approved exe structs.");
+
+    pApprovedExes->cApprovedExes = cNodes;
+
+    // parse approved exe elements
+    for (DWORD i = 0; i < cNodes; ++i)
+    {
+        BURN_APPROVED_EXE* pApprovedExe = &pApprovedExes->rgApprovedExes[i];
+
+        hr = XmlNextElement(pixnNodes, &pixnNode, NULL);
+        ExitOnFailure(hr, "Failed to get next node.");
+
+        // @Id
+        hr = XmlGetAttributeEx(pixnNode, L"Id", &pApprovedExe->sczId);
+        ExitOnFailure(hr, "Failed to get @Id.");
+
+        // @Key
+        hr = XmlGetAttributeEx(pixnNode, L"Key", &pApprovedExe->sczKey);
+        ExitOnFailure(hr, "Failed to get @Key.");
+
+        // @ValueName
+        hr = XmlGetAttributeEx(pixnNode, L"ValueName", &pApprovedExe->sczValueName);
+        if (E_NOTFOUND != hr)
+        {
+            ExitOnFailure(hr, "Failed to get @ValueName.");
+        }
+
+        // @Win64
+        hr = XmlGetYesNoAttribute(pixnNode, L"Win64", &pApprovedExe->fWin64);
+        if (E_NOTFOUND != hr)
+        {
+            ExitOnFailure(hr, "Failed to get @Win64.");
+        }
+
+        // prepare next iteration
+        ReleaseNullObject(pixnNode);
+        ReleaseNullStr(scz);
+    }
+
+    hr = S_OK;
+
+LExit:
+    ReleaseObject(pixnNodes);
+    ReleaseObject(pixnNode);
+    ReleaseStr(scz);
+    return hr;
+}
+
+extern "C" void ApprovedExesUninitialize(
+    __in BURN_APPROVED_EXES* pApprovedExes
+    )
+{
+    if (pApprovedExes->rgApprovedExes)
+    {
+        for (DWORD i = 0; i < pApprovedExes->cApprovedExes; ++i)
+        {
+            BURN_APPROVED_EXE* pApprovedExe = &pApprovedExes->rgApprovedExes[i];
+
+            ReleaseStr(pApprovedExe->sczId);
+            ReleaseStr(pApprovedExe->sczKey);
+            ReleaseStr(pApprovedExe->sczValueName);
+        }
+        MemFree(pApprovedExes->rgApprovedExes);
+    }
+}
+
+extern "C" void ApprovedExesUninitializeLaunch(
+    __in BURN_LAUNCH_APPROVED_EXE* pLaunchApprovedExe
+    )
+{
+    if (pLaunchApprovedExe)
+    {
+        ReleaseStr(pLaunchApprovedExe->sczArguments);
+        ReleaseStr(pLaunchApprovedExe->sczExecutablePath);
+        ReleaseStr(pLaunchApprovedExe->sczId);
+        MemFree(pLaunchApprovedExe);
+    }
+}
+
+extern "C" HRESULT ApprovedExesFindById(
+    __in BURN_APPROVED_EXES* pApprovedExes,
+    __in_z LPCWSTR wzId,
+    __out BURN_APPROVED_EXE** ppApprovedExe
+    )
+{
+    HRESULT hr = S_OK;
+    BURN_APPROVED_EXE* pApprovedExe = NULL;
+
+    for (DWORD i = 0; i < pApprovedExes->cApprovedExes; ++i)
+    {
+        pApprovedExe = &pApprovedExes->rgApprovedExes[i];
+
+        if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, pApprovedExe->sczId, -1, wzId, -1))
+        {
+            *ppApprovedExe = pApprovedExe;
+            ExitFunction1(hr = S_OK);
+        }
+    }
+
+    hr = E_NOTFOUND;
+
+LExit:
+    return hr;
+}
+
+extern "C" HRESULT ApprovedExesLaunch(
+    __in BURN_VARIABLES* pVariables,
+    __in BURN_LAUNCH_APPROVED_EXE* pLaunchApprovedExe,
+    __out DWORD* pdwProcessId
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR sczArgumentsFormatted = NULL;
+    LPWSTR sczArgumentsObfuscated = NULL;
+    LPWSTR sczCommand = NULL;
+    LPWSTR sczCommandObfuscated = NULL;
+    LPWSTR sczExecutableDirectory = NULL;
+    STARTUPINFOW si = { };
+    PROCESS_INFORMATION pi = { };
+
+    // build command
+    if (pLaunchApprovedExe->sczArguments && *pLaunchApprovedExe->sczArguments)
+    {
+        hr = VariableFormatString(pVariables, pLaunchApprovedExe->sczArguments, &sczArgumentsFormatted, NULL);
+        ExitOnFailure(hr, "Failed to format argument string.");
+
+        hr = StrAllocFormattedSecure(&sczCommand, L"\"%ls\" %s", pLaunchApprovedExe->sczExecutablePath, sczArgumentsFormatted);
+        ExitOnFailure(hr, "Failed to create executable command.");
+
+        hr = VariableFormatStringObfuscated(pVariables, pLaunchApprovedExe->sczArguments, &sczArgumentsObfuscated, NULL);
+        ExitOnFailure(hr, "Failed to format obfuscated argument string.");
+
+        hr = StrAllocFormatted(&sczCommandObfuscated, L"\"%ls\" %s", pLaunchApprovedExe->sczExecutablePath, sczArgumentsObfuscated);
+    }
+    else
+    {
+        hr = StrAllocFormatted(&sczCommand, L"\"%ls\"", pLaunchApprovedExe->sczExecutablePath);
+        ExitOnFailure(hr, "Failed to create executable command.");
+
+        hr = StrAllocFormatted(&sczCommandObfuscated, L"\"%ls\"", pLaunchApprovedExe->sczExecutablePath);
+    }
+    ExitOnFailure(hr, "Failed to create obfuscated executable command.");
+
+    // Try to get the directory of the executable so we can set the current directory of the process to help those executables
+    // that expect stuff to be relative to them.  Best effort only.
+    hr = PathGetDirectory(pLaunchApprovedExe->sczExecutablePath, &sczExecutableDirectory);
+    if (FAILED(hr))
+    {
+        ReleaseNullStr(sczExecutableDirectory);
+    }
+
+    LogId(REPORT_STANDARD, MSG_LAUNCHING_APPROVED_EXE, pLaunchApprovedExe->sczExecutablePath, sczCommandObfuscated);
+
+    si.cb = sizeof(si);
+    if (!::CreateProcessW(pLaunchApprovedExe->sczExecutablePath, sczCommand, NULL, NULL, FALSE, CREATE_NEW_PROCESS_GROUP, NULL, sczExecutableDirectory, &si, &pi))
+    {
+        ExitWithLastError(hr, "Failed to CreateProcess on path: %ls", pLaunchApprovedExe->sczExecutablePath);
+    }
+
+    *pdwProcessId = pi.dwProcessId;
+
+    if (pLaunchApprovedExe->dwWaitForInputIdleTimeout)
+    {
+        ::WaitForInputIdle(pi.hProcess, pLaunchApprovedExe->dwWaitForInputIdleTimeout);
+    }
+
+LExit:
+    StrSecureZeroFreeString(sczArgumentsFormatted);
+    ReleaseStr(sczArgumentsObfuscated);
+    StrSecureZeroFreeString(sczCommand);
+    ReleaseStr(sczCommandObfuscated);
+    ReleaseStr(sczExecutableDirectory);
+
+    ReleaseHandle(pi.hThread);
+    ReleaseHandle(pi.hProcess);
+
+    return hr;
+}
+
+extern "C" HRESULT ApprovedExesVerifySecureLocation(
+    __in BURN_VARIABLES* pVariables,
+    __in BURN_LAUNCH_APPROVED_EXE* pLaunchApprovedExe
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR scz = NULL;
+
+    const LPCWSTR vrgSecureFolderVariables[] = {
+        L"ProgramFiles64Folder",
+        L"ProgramFilesFolder",
+    };
+
+    for (DWORD i = 0; i < countof(vrgSecureFolderVariables); ++i)
+    {
+        LPCWSTR wzSecureFolderVariable = vrgSecureFolderVariables[i];
+
+        hr = VariableGetString(pVariables, wzSecureFolderVariable, &scz);
+        if (SUCCEEDED(hr))
+        {
+            hr = PathDirectoryContainsPath(scz, pLaunchApprovedExe->sczExecutablePath);
+            if (S_OK == hr)
+            {
+                ExitFunction();
+            }
+        }
+        else if (E_NOTFOUND != hr)
+        {
+            ExitOnFailure(hr, "Failed to get the variable: %ls", wzSecureFolderVariable);
+        }
+    }
+
+    // The problem with using a Variable for the root package cache folder is that it might not have been secured yet.
+    // Getting it through CacheGetRootCompletedPath makes sure it has been secured.
+    hr = CacheGetRootCompletedPath(TRUE, TRUE, &scz);
+    ExitOnFailure(hr, "Failed to get the root package cache folder.");
+
+    hr = PathDirectoryContainsPath(scz, pLaunchApprovedExe->sczExecutablePath);
+    if (S_OK == hr)
+    {
+        ExitFunction();
+    }
+
+    hr = S_FALSE;
+
+LExit:
+    ReleaseStr(scz);
+
+    return hr;
+}
diff --git a/src/engine/approvedexe.h b/src/engine/approvedexe.h
new file mode 100644
index 00000000..23f3b1bb
--- /dev/null
+++ b/src/engine/approvedexe.h
@@ -0,0 +1,67 @@
+#pragma once
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+
+// structs
+
+typedef struct _BURN_APPROVED_EXE
+{
+    LPWSTR sczId;
+    LPWSTR sczKey;
+    LPWSTR sczValueName;
+    BOOL fWin64;
+} BURN_APPROVED_EXE;
+
+typedef struct _BURN_APPROVED_EXES
+{
+    BURN_APPROVED_EXE* rgApprovedExes;
+    DWORD cApprovedExes;
+} BURN_APPROVED_EXES;
+
+typedef struct _BURN_LAUNCH_APPROVED_EXE
+{
+    HWND hwndParent;
+    LPWSTR sczId;
+    LPWSTR sczExecutablePath;
+    LPWSTR sczArguments;
+    DWORD dwWaitForInputIdleTimeout;
+} BURN_LAUNCH_APPROVED_EXE;
+
+
+// function declarations
+
+HRESULT ApprovedExesParseFromXml(
+    __in BURN_APPROVED_EXES* pApprovedExes,
+    __in IXMLDOMNode* pixnBundle
+    );
+
+void ApprovedExesUninitialize(
+    __in BURN_APPROVED_EXES* pApprovedExes
+    );
+void ApprovedExesUninitializeLaunch(
+    __in BURN_LAUNCH_APPROVED_EXE* pLaunchApprovedExe
+    );
+HRESULT ApprovedExesFindById(
+    __in BURN_APPROVED_EXES* pApprovedExes,
+    __in_z LPCWSTR wzId,
+    __out BURN_APPROVED_EXE** ppApprovedExe
+    );
+HRESULT ApprovedExesLaunch(
+    __in BURN_VARIABLES* pVariables,
+    __in BURN_LAUNCH_APPROVED_EXE* pLaunchApprovedExe,
+    __out DWORD* pdwProcessId
+    );
+HRESULT ApprovedExesVerifySecureLocation(
+    __in BURN_VARIABLES* pVariables,
+    __in BURN_LAUNCH_APPROVED_EXE* pLaunchApprovedExe
+    );
+
+
+#if defined(__cplusplus)
+}
+#endif
diff --git a/src/engine/bitsengine.cpp b/src/engine/bitsengine.cpp
new file mode 100644
index 00000000..b8093b77
--- /dev/null
+++ b/src/engine/bitsengine.cpp
@@ -0,0 +1,505 @@
+// 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.
+
+#include "precomp.h"
+
+// const
+
+const DWORD BITSENGINE_NO_PROGRESS_TIMEOUT = 2 * 60;
+const DWORD BITSENGINE_MSG_WAIT_TIMEOUT = 1;
+
+// functions
+
+static HRESULT CreateJob(
+    __out IBackgroundCopyJob** ppJob
+    );
+static HRESULT SetCredentials(
+    __in IBackgroundCopyJob* pJob,
+    __in_z_opt LPCWSTR wzUser,
+    __in_z_opt LPCWSTR wzPassword
+    );
+static void SendError(
+    __in DOWNLOAD_CACHE_CALLBACK* pCacheCallback,
+    __in IBackgroundCopyJob* pJob,
+    __in HRESULT hrError,
+    __in BG_ERROR_CONTEXT context,
+    __out_opt BOOL* pfRetry
+    );
+
+
+// class
+
+class CBurnBitsCallback : public IBackgroundCopyCallback
+{
+public: // IUnknown
+    virtual STDMETHODIMP QueryInterface(
+        __in const IID& riid,
+        __out void** ppvObject
+        )
+    {
+        HRESULT hr = S_OK;
+
+        ExitOnNull(ppvObject, hr, E_INVALIDARG, "Invalid argument ppvObject");
+        *ppvObject = NULL;
+
+        if (::IsEqualIID(__uuidof(IBackgroundCopyCallback), riid))
+        {
+            *ppvObject = static_cast<IBackgroundCopyCallback*>(this);
+        }
+        else if (::IsEqualIID(IID_IUnknown, riid))
+        {
+            *ppvObject = reinterpret_cast<IUnknown*>(this);
+        }
+        else // no interface for requested iid
+        {
+            ExitFunction1(hr = E_NOINTERFACE);
+        }
+
+        AddRef();
+
+    LExit:
+        return hr;
+    }
+
+    virtual STDMETHODIMP_(ULONG) AddRef()
+    {
+        return ::InterlockedIncrement(&this->m_cReferences);
+    }
+
+    virtual STDMETHODIMP_(ULONG) Release()
+    {
+        long l = ::InterlockedDecrement(&this->m_cReferences);
+        if (0 < l)
+        {
+            return l;
+        }
+
+        delete this;
+        return 0;
+    }
+
+public: // IBackgroundCopyCallback
+    virtual STDMETHODIMP JobTransferred(
+        __in IBackgroundCopyJob* pJob
+        )
+    {
+        HRESULT hr = S_OK;
+
+        hr = SendProgress(pJob);
+        ExitOnFailure(hr, "Failure while sending progress during BITS job transferred.");
+
+    LExit:
+        if (FAILED(hr))
+        {
+            ProcessResult(BG_ERROR_CONTEXT_NONE, hr);
+        }
+        else
+        {
+            ::SetEvent(m_hComplete);
+        }
+
+        return S_OK; // must return S_OK otherwise BITS just keeps calling back.
+    }
+
+    virtual STDMETHODIMP JobError(
+        __in IBackgroundCopyJob* /*pJob*/,
+        __in IBackgroundCopyError* pError
+        )
+    {
+        HRESULT hr = S_OK;
+        BG_ERROR_CONTEXT context = BG_ERROR_CONTEXT_NONE;
+        HRESULT hrError = S_OK;
+
+        hr = pError->GetError(&context, &hrError);
+        ExitOnFailure(hr, "Failed to get error context.");
+
+        if (SUCCEEDED(hrError))
+        {
+            hr = E_UNEXPECTED;
+        }
+
+    LExit:
+        ProcessResult(context, FAILED(hrError) ? hrError : hr);
+
+        return S_OK; // must return S_OK otherwise BITS just keeps calling back.
+    }
+
+    virtual STDMETHODIMP JobModification(
+        __in IBackgroundCopyJob* pJob,
+        __in DWORD /*dwReserved*/
+        )
+    {
+        HRESULT hr = S_OK;
+        BG_JOB_STATE state = BG_JOB_STATE_ERROR;
+
+        ::EnterCriticalSection(&m_cs);
+
+        hr = pJob->GetState(&state);
+        ExitOnFailure(hr, "Failed to get state during job modification.");
+
+        // If we're actually downloading stuff, let's send progress.
+        if (BG_JOB_STATE_TRANSFERRING == state)
+        {
+            hr = SendProgress(pJob);
+            ExitOnFailure(hr, "Failure while sending progress during BITS job modification.");
+        }
+
+    LExit:
+        ::LeaveCriticalSection(&m_cs);
+
+        ProcessResult(BG_ERROR_CONTEXT_NONE, hr);
+
+        return S_OK; // documentation says to always return S_OK
+    }
+
+public:
+    void Reset()
+    {
+        m_hrError = S_OK;
+        m_contextError = BG_ERROR_CONTEXT_NONE;
+
+        ::ResetEvent(m_hComplete);
+    }
+
+    HRESULT WaitForCompletion(
+        __in IBackgroundCopyJob* pJob
+        )
+    {
+        HRESULT hr = S_OK;
+        HANDLE rghEvents[1] = { m_hComplete };
+        MSG msg = { };
+        BOOL fMessageProcessed = FALSE;
+
+        do
+        {
+            fMessageProcessed = FALSE;
+
+            switch (::MsgWaitForMultipleObjects(countof(rghEvents), rghEvents, FALSE, BITSENGINE_MSG_WAIT_TIMEOUT * 1000, QS_ALLINPUT))
+            {
+            case WAIT_OBJECT_0:
+                break;
+
+            case WAIT_OBJECT_0 + 1:
+                ::PeekMessageW(&msg, NULL, 0, 0, PM_NOREMOVE);
+                fMessageProcessed = TRUE;
+                break;
+
+            case WAIT_TIMEOUT:
+                // Call the progress callback periodically if we are not transferring to ensure that cancelling is responsive
+                // (progress callback is also handles cancelling).  Note that if we are transferring, IBackgroundCopyCallback
+                // methods handle progress/cancelling.  If we are not transferring, the IBackgroundCopyCallback methods may
+                // not be called until the job times out (minutes for a foreground job, weeks for a background job).
+                SendProgressIfNotTransferring(pJob);
+                fMessageProcessed = TRUE;
+                break;
+
+            default:
+                ExitWithLastError(hr, "Failed while waiting for download.");
+            }
+        } while (fMessageProcessed);
+
+    LExit:
+        return hr;
+    }
+
+    void GetError(
+        __out HRESULT* pHR,
+        __out BG_ERROR_CONTEXT* pContext
+        )
+    {
+        *pHR = m_hrError;
+        *pContext = m_contextError;
+    }
+
+private:
+    HRESULT SendProgress(
+        __in IBackgroundCopyJob* pJob
+        )
+    {
+        HRESULT hr = S_OK;
+        BG_JOB_PROGRESS progress = { };
+
+        if (m_pCallback && m_pCallback->pfnProgress)
+        {
+            hr = pJob->GetProgress(&progress);
+            ExitOnFailure(hr, "Failed to get progress when BITS job was transferred.");
+
+            hr = CacheSendProgressCallback(m_pCallback, progress.BytesTransferred, progress.BytesTotal, INVALID_HANDLE_VALUE);
+            ExitOnFailure(hr, "Failed to send progress from BITS job.");
+        }
+
+    LExit:
+        return hr;
+    }
+
+    void SendProgressIfNotTransferring(
+        __in IBackgroundCopyJob* pJob
+        )
+    {
+        HRESULT hr = S_OK;
+        BG_JOB_STATE state = BG_JOB_STATE_ERROR;
+
+        ::EnterCriticalSection(&m_cs);
+
+        hr = pJob->GetState(&state);
+        ExitOnFailure(hr, "Failed to get BITS job state.");
+
+        if (BG_JOB_STATE_TRANSFERRING != state)
+        {
+            hr = SendProgress(pJob);
+            ExitOnFailure(hr, "Failure while sending progress.");
+        }
+
+    LExit:
+        ::LeaveCriticalSection(&m_cs);
+
+        ProcessResult(BG_ERROR_CONTEXT_NONE, hr);
+    }
+
+    void ProcessResult(
+        __in BG_ERROR_CONTEXT context,
+        __in HRESULT hr
+        )
+    {
+        if (FAILED(hr))
+        {
+            m_contextError = context;
+            m_hrError = hr;
+
+            ::SetEvent(m_hComplete);
+        }
+    }
+
+public:
+    CBurnBitsCallback(
+        __in_opt DOWNLOAD_CACHE_CALLBACK* pCallback,
+        __out HRESULT* pHR
+        )
+    {
+        HRESULT hr = S_OK;
+
+        m_cReferences = 1;
+        ::InitializeCriticalSection(&m_cs);
+
+        m_hComplete = ::CreateEventW(NULL, TRUE, FALSE, NULL);
+        ExitOnNullWithLastError(m_hComplete, hr, "Failed to create BITS job complete event.");
+
+        m_contextError = BG_ERROR_CONTEXT_NONE;
+        m_hrError = S_OK;
+
+        m_pCallback = pCallback;
+
+    LExit:
+        *pHR = hr;
+    }
+
+    ~CBurnBitsCallback()
+    {
+        m_pCallback = NULL;
+        ReleaseHandle(m_hComplete);
+        ::DeleteCriticalSection(&m_cs);
+    }
+
+private:
+    long m_cReferences;
+    CRITICAL_SECTION m_cs;
+    BG_ERROR_CONTEXT m_contextError;
+    HRESULT m_hrError;
+
+    HANDLE m_hComplete;
+    DOWNLOAD_CACHE_CALLBACK* m_pCallback;
+};
+
+
+extern "C" HRESULT BitsDownloadUrl(
+    __in DOWNLOAD_CACHE_CALLBACK* pCallback,
+    __in DOWNLOAD_SOURCE* pDownloadSource,
+    __in_z LPCWSTR wzDestinationPath
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR sczDownloadUrl = NULL;
+    CBurnBitsCallback* pBitsCallback = NULL;
+    IBackgroundCopyJob* pJob = NULL;
+    BOOL fRetry = FALSE;
+    BG_ERROR_CONTEXT contextError = BG_ERROR_CONTEXT_NONE;
+
+    // If the URL isn't at least 8 characters long (e.g.: "bits://X") then it
+    // isn't going to do us any good.
+    if (8 > lstrlenW(pDownloadSource->sczUrl))
+    {
+        hr = E_INVALIDARG;
+        ExitOnRootFailure(hr, "Invalid BITS engine URL: %ls", pDownloadSource->sczUrl);
+    }
+
+    // Fix the URL to be "http" instead of "bits".
+    hr = StrAllocString(&sczDownloadUrl, pDownloadSource->sczUrl, 0);
+    ExitOnFailure(hr, "Failed to copy download URL.");
+
+    sczDownloadUrl[0] = L'h';
+    sczDownloadUrl[1] = L't';
+    sczDownloadUrl[2] = L't';
+    sczDownloadUrl[3] = L'p';
+
+    // Create and configure the BITS job.
+    hr = CreateJob(&pJob);
+    ExitOnFailure(hr, "Failed to create BITS job.");
+
+    hr = SetCredentials(pJob, pDownloadSource->sczUser, pDownloadSource->sczPassword);
+    ExitOnFailure(hr, "Failed to set credentials for BITS job.");
+
+    hr = pJob->AddFile(sczDownloadUrl, wzDestinationPath);
+    ExitOnFailure(hr, "Failed to add file to BITS job.");
+
+    // Set the callback into the BITs job.
+    pBitsCallback = new CBurnBitsCallback(pCallback, &hr);
+    ExitOnNull(pBitsCallback, hr, E_OUTOFMEMORY, "Failed to create BITS job callback.");
+    ExitOnFailure(hr, "Failed to initialize BITS job callback.");
+
+    hr = pJob->SetNotifyInterface(pBitsCallback);
+    ExitOnFailure(hr, "Failed to set callback interface for BITS job.");
+
+    // Go into our retry download loop.
+    do
+    {
+        fRetry = FALSE;
+
+        pBitsCallback->Reset(); // ensure we are ready for the download to start (again?).
+
+        hr = pJob->Resume();
+        ExitOnFailure(hr, "Falied to start BITS job.");
+
+        hr = pBitsCallback->WaitForCompletion(pJob);
+        ExitOnFailure(hr, "Failed while waiting for BITS download.");
+
+        // See if there are any errors.
+        pBitsCallback->GetError(&hr, &contextError);
+        if (HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT) == hr)
+        {
+            ExitFunction();
+        }
+        else if (FAILED(hr))
+        {
+            SendError(pCallback, pJob, hr, contextError, &fRetry);
+        }
+    } while (fRetry);
+    ExitOnFailure(hr, "Failed to download BITS job.");
+
+    // After all that, we should have the file downloaded so complete the job to get
+    // the file copied to the destination.
+    hr = pJob->Complete();
+    ExitOnFailure(hr, "Failed to complete BITS job.");
+
+LExit:
+    if (pJob)
+    {
+        pJob->SetNotifyInterface(NULL);
+
+        // If we failed, kill the job.
+        if (FAILED(hr))
+        {
+            pJob->Cancel(); // TODO: should we cancel if we're going to retry the package? Probably the right thing to do.
+        }
+    }
+
+    ReleaseObject(pBitsCallback);
+    ReleaseObject(pJob);
+    ReleaseStr(sczDownloadUrl);
+
+    return hr;
+}
+
+static HRESULT CreateJob(
+    __out IBackgroundCopyJob** ppJob
+    )
+{
+    HRESULT hr = S_OK;
+    IBackgroundCopyManager* pBitsManager = NULL;
+    IBackgroundCopyJob* pJob = NULL;
+    GUID guidJob = { };
+
+    hr = ::CoCreateInstance(__uuidof(BackgroundCopyManager), NULL, CLSCTX_ALL, __uuidof(IBackgroundCopyManager), reinterpret_cast<LPVOID*>(&pBitsManager));
+    ExitOnFailure(hr, "Failed to create IBackgroundCopyManager.");
+
+    hr = pBitsManager->CreateJob(L"WixBurn", BG_JOB_TYPE_DOWNLOAD, &guidJob, &pJob);
+    ExitOnFailure(hr, "Failed to create BITS job.");
+
+    hr = pJob->SetNotifyFlags(BG_NOTIFY_JOB_TRANSFERRED | BG_NOTIFY_JOB_ERROR | BG_NOTIFY_JOB_MODIFICATION);
+    ExitOnFailure(hr, "Failed to set notification flags for BITS job.");
+
+    hr = pJob->SetNoProgressTimeout(BITSENGINE_NO_PROGRESS_TIMEOUT); // use 2 minutes since default is 14 days.
+    ExitOnFailure(hr, "Failed to set progress timeout.");
+
+    hr = pJob->SetPriority(BG_JOB_PRIORITY_FOREGROUND);
+    ExitOnFailure(hr, "Failed to set BITS job to foreground.");
+
+    *ppJob = pJob;
+    pJob = NULL;
+
+LExit:
+    ReleaseObject(pJob);
+    ReleaseObject(pBitsManager);
+
+    return hr;
+}
+
+static HRESULT SetCredentials(
+    __in IBackgroundCopyJob* pJob,
+    __in_z_opt LPCWSTR wzUser,
+    __in_z_opt LPCWSTR wzPassword
+    )
+{
+    HRESULT hr = S_OK;
+    IBackgroundCopyJob2* pJob2 = NULL;
+    BG_AUTH_CREDENTIALS ac = { };
+
+    // If IBackgroundCopyJob2::SetCredentials() is supported, set the username/password.
+    hr = pJob->QueryInterface(IID_PPV_ARGS(&pJob2));
+    if (SUCCEEDED(hr))
+    {
+        ac.Target = BG_AUTH_TARGET_PROXY;
+        ac.Credentials.Basic.UserName = const_cast<LPWSTR>(wzUser);
+        ac.Credentials.Basic.Password = const_cast<LPWSTR>(wzPassword);
+
+        ac.Scheme = BG_AUTH_SCHEME_NTLM;
+        hr = pJob2->SetCredentials(&ac);
+        ExitOnFailure(hr, "Failed to set background copy NTLM credentials");
+
+        ac.Scheme = BG_AUTH_SCHEME_NEGOTIATE;
+        hr = pJob2->SetCredentials(&ac);
+        ExitOnFailure(hr, "Failed to set background copy negotiate credentials");
+    }
+
+    hr = S_OK;
+
+LExit:
+    ReleaseObject(pJob2);
+
+    return hr;
+}
+
+static void SendError(
+    __in DOWNLOAD_CACHE_CALLBACK* pCacheCallback,
+    __in IBackgroundCopyJob* pJob,
+    __in HRESULT hrError,
+    __in BG_ERROR_CONTEXT /*context*/,
+    __out_opt BOOL* pfRetry
+    )
+{
+    HRESULT hr = S_OK;
+    IBackgroundCopyError* pError = NULL;
+    LPWSTR pszErrorDescription = NULL;
+
+    hr = pJob->GetError(&pError);
+    if (SUCCEEDED(hr))
+    {
+        pError->GetErrorDescription(LANGIDFROMLCID(::GetThreadLocale()), &pszErrorDescription);
+    }
+
+    CacheSendErrorCallback(pCacheCallback, hrError, pszErrorDescription, pfRetry);
+
+    if (pszErrorDescription)
+    {
+        ::CoTaskMemFree(pszErrorDescription);
+    }
+    ReleaseObject(pError);
+}
diff --git a/src/engine/bitsengine.h b/src/engine/bitsengine.h
new file mode 100644
index 00000000..b1c1d805
--- /dev/null
+++ b/src/engine/bitsengine.h
@@ -0,0 +1,23 @@
+#pragma once
+// 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.
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// structs
+
+
+// functions
+
+HRESULT BitsDownloadUrl(
+    __in DOWNLOAD_CACHE_CALLBACK* pCallback,
+    __in DOWNLOAD_SOURCE* pDownloadSource,
+    __in LPCWSTR wzDestinationPath
+    );
+
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/engine/cabextract.cpp b/src/engine/cabextract.cpp
new file mode 100644
index 00000000..04c2c6ec
--- /dev/null
+++ b/src/engine/cabextract.cpp
@@ -0,0 +1,974 @@
+// 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.
+
+#include "precomp.h"
+
+#include <fdi.h>
+
+#define ARRAY_GROWTH_SIZE 2
+
+const LPSTR INVALID_CAB_NAME = "<the>.cab";
+
+// structs
+
+typedef struct _BURN_CAB_CONTEXT
+{
+    HANDLE hFile;
+    DWORD64 qwOffset;
+    DWORD64 qwSize;
+
+    HANDLE hThread;
+    HANDLE hBeginOperationEvent;
+    HANDLE hOperationCompleteEvent;
+
+    BURN_CAB_OPERATION operation;
+    HRESULT hrError;
+
+    LPWSTR* psczStreamName;
+    LPCWSTR wzTargetFile;
+    HANDLE hTargetFile;
+    BYTE* pbTargetBuffer;
+    DWORD cbTargetBuffer;
+    DWORD iTargetBuffer;
+} BURN_CAB_CONTEXT;
+
+
+// internal function declarations
+
+static HRESULT BeginAndWaitForOperation(
+    __in BURN_CONTAINER_CONTEXT* pContext
+    );
+static HRESULT WaitForOperation(
+    __in BURN_CONTAINER_CONTEXT* pContext
+    );
+static DWORD WINAPI ExtractThreadProc(
+    __in LPVOID lpThreadParameter
+    );
+static INT_PTR DIAMONDAPI CabNotifyCallback(
+    __in FDINOTIFICATIONTYPE iNotification,
+    __inout FDINOTIFICATION *pFDINotify
+    );
+static INT_PTR CopyFileCallback(
+    __in BURN_CONTAINER_CONTEXT* pContext,
+    __inout FDINOTIFICATION *pFDINotify
+    );
+static INT_PTR CloseFileInfoCallback(
+    __in BURN_CONTAINER_CONTEXT* pContext,
+    __inout FDINOTIFICATION *pFDINotify
+    );
+static LPVOID DIAMONDAPI CabAlloc(
+    __in DWORD dwSize
+    );
+static void DIAMONDAPI CabFree(
+    __in LPVOID pvData
+    );
+static INT_PTR FAR DIAMONDAPI CabOpen(
+    __in char FAR *pszFile,
+    __in int /* oflag */,
+    __in int /* pmode */
+    );
+static UINT FAR DIAMONDAPI CabRead(
+    __in INT_PTR hf,
+    __out void FAR *pv,
+    __in UINT cb
+    );
+static UINT FAR DIAMONDAPI CabWrite(
+    __in INT_PTR hf,
+    __in void FAR *pv,
+    __in UINT cb
+    );
+static long FAR DIAMONDAPI CabSeek(
+    __in INT_PTR hf,
+    __in long dist,
+    __in int seektype
+    );
+static int FAR DIAMONDAPI CabClose(
+    __in INT_PTR hf
+    );
+static HRESULT AddVirtualFilePointer(
+    __in BURN_CONTAINER_CONTEXT_CABINET* pCabinetContext,
+    __in HANDLE hFile,
+    __in LONGLONG llInitialFilePointer
+    );
+static HRESULT ReadIfVirtualFilePointer(
+    __in BURN_CONTAINER_CONTEXT_CABINET* pCabinetContext,
+    __in HANDLE hFile,
+    __in DWORD cbRead
+    );
+static BOOL SetIfVirtualFilePointer(
+    __in BURN_CONTAINER_CONTEXT_CABINET* pCabinetContext,
+    __in HANDLE hFile,
+    __in LONGLONG llDistance,
+    __out LONGLONG* pllNewPostion,
+    __in DWORD dwSeekType
+    );
+static HRESULT CloseIfVirturalFilePointer(
+    __in BURN_CONTAINER_CONTEXT_CABINET* pCabinetContext,
+    __in HANDLE hFile
+    );
+static BURN_CONTAINER_CONTEXT_CABINET_VIRTUAL_FILE_POINTER* GetVirtualFilePointer(
+    __in BURN_CONTAINER_CONTEXT_CABINET* pCabinetContext,
+    __in HANDLE hFile
+    );
+
+
+// internal variables
+
+__declspec(thread) static BURN_CONTAINER_CONTEXT* vpContext;
+
+
+// function definitions
+
+extern "C" void CabExtractInitialize()
+{
+}
+
+extern "C" HRESULT CabExtractOpen(
+    __in BURN_CONTAINER_CONTEXT* pContext,
+    __in LPCWSTR wzFilePath
+    )
+{
+    HRESULT hr = S_OK;
+
+    // initialize context
+    pContext->Cabinet.hTargetFile = INVALID_HANDLE_VALUE;
+
+    hr = StrAllocString(&pContext->Cabinet.sczFile, wzFilePath, 0);
+    ExitOnFailure(hr, "Failed to copy file name.");
+
+    // create events
+    pContext->Cabinet.hBeginOperationEvent = ::CreateEventW(NULL, TRUE, FALSE, NULL);
+    ExitOnNullWithLastError(pContext->Cabinet.hBeginOperationEvent, hr, "Failed to create begin operation event.");
+
+    pContext->Cabinet.hOperationCompleteEvent = ::CreateEventW(NULL, TRUE, FALSE, NULL);
+    ExitOnNullWithLastError(pContext->Cabinet.hOperationCompleteEvent, hr, "Failed to create operation complete event.");
+
+    // create extraction thread
+    pContext->Cabinet.hThread = ::CreateThread(NULL, 0, ExtractThreadProc, pContext, 0, NULL);
+    ExitOnNullWithLastError(pContext->Cabinet.hThread, hr, "Failed to create extraction thread.");
+
+    // wait for operation to complete
+    hr = WaitForOperation(pContext);
+    ExitOnFailure(hr, "Failed to wait for operation complete.");
+
+LExit:
+    return hr;
+}
+
+extern "C" HRESULT CabExtractNextStream(
+    __in BURN_CONTAINER_CONTEXT* pContext,
+    __inout_z LPWSTR* psczStreamName
+    )
+{
+    HRESULT hr = S_OK;
+
+    // set operation to move to next stream
+    pContext->Cabinet.operation = BURN_CAB_OPERATION_NEXT_STREAM;
+    pContext->Cabinet.psczStreamName = psczStreamName;
+
+    // begin operation and wait
+    hr = BeginAndWaitForOperation(pContext);
+    if (E_ABORT != hr && E_NOMOREITEMS != hr)
+    {
+        ExitOnFailure(hr, "Failed to begin and wait for operation.");
+    }
+
+LExit:
+    return hr;
+}
+
+extern "C" HRESULT CabExtractStreamToFile(
+    __in BURN_CONTAINER_CONTEXT* pContext,
+    __in_z LPCWSTR wzFileName
+    )
+{
+    HRESULT hr = S_OK;
+
+    // set operation to move to next stream
+    pContext->Cabinet.operation = BURN_CAB_OPERATION_STREAM_TO_FILE;
+    pContext->Cabinet.wzTargetFile = wzFileName;
+
+    // begin operation and wait
+    hr = BeginAndWaitForOperation(pContext);
+    ExitOnFailure(hr, "Failed to begin and wait for operation.");
+
+    // clear file name
+    pContext->Cabinet.wzTargetFile = NULL;
+
+LExit:
+    return hr;
+}
+
+extern "C" HRESULT CabExtractStreamToBuffer(
+    __in BURN_CONTAINER_CONTEXT* pContext,
+    __out BYTE** ppbBuffer,
+    __out SIZE_T* pcbBuffer
+    )
+{
+    HRESULT hr = S_OK;
+
+    // set operation to move to next stream
+    pContext->Cabinet.operation = BURN_CAB_OPERATION_STREAM_TO_BUFFER;
+
+    // begin operation and wait
+    hr = BeginAndWaitForOperation(pContext);
+    ExitOnFailure(hr, "Failed to begin and wait for operation.");
+
+    // return values
+    *ppbBuffer = pContext->Cabinet.pbTargetBuffer;
+    *pcbBuffer = pContext->Cabinet.cbTargetBuffer;
+
+    // clear buffer variables
+    pContext->Cabinet.pbTargetBuffer = NULL;
+    pContext->Cabinet.cbTargetBuffer = 0;
+    pContext->Cabinet.iTargetBuffer = 0;
+
+LExit:
+    return hr;
+}
+
+extern "C" HRESULT CabExtractSkipStream(
+    __in BURN_CONTAINER_CONTEXT* pContext
+    )
+{
+    HRESULT hr = S_OK;
+
+    // set operation to move to next stream
+    pContext->Cabinet.operation = BURN_CAB_OPERATION_SKIP_STREAM;
+
+    // begin operation and wait
+    hr = BeginAndWaitForOperation(pContext);
+    ExitOnFailure(hr, "Failed to begin and wait for operation.");
+
+LExit:
+    return hr;
+}
+
+extern "C" HRESULT CabExtractClose(
+    __in BURN_CONTAINER_CONTEXT* pContext
+    )
+{
+    HRESULT hr = S_OK;
+
+    // terminate worker thread
+    if (pContext->Cabinet.hThread)
+    {
+        // set operation to move to close
+        pContext->Cabinet.operation = BURN_CAB_OPERATION_CLOSE;
+
+        // set begin operation event
+        if (!::SetEvent(pContext->Cabinet.hBeginOperationEvent))
+        {
+            ExitWithLastError(hr, "Failed to set begin operation event.");
+        }
+
+        // wait for thread to terminate
+        if (WAIT_OBJECT_0 != ::WaitForSingleObject(pContext->Cabinet.hThread, INFINITE))
+        {
+            ExitWithLastError(hr, "Failed to wait for thread to terminate.");
+        }
+    }
+
+LExit:
+    ReleaseHandle(pContext->Cabinet.hThread);
+    ReleaseHandle(pContext->Cabinet.hBeginOperationEvent);
+    ReleaseHandle(pContext->Cabinet.hOperationCompleteEvent);
+    ReleaseMem(pContext->Cabinet.rgVirtualFilePointers);
+    ReleaseStr(pContext->Cabinet.sczFile);
+
+    return hr;
+}
+
+
+// internal helper functions
+
+static HRESULT BeginAndWaitForOperation(
+    __in BURN_CONTAINER_CONTEXT* pContext
+    )
+{
+    HRESULT hr = S_OK;
+
+    // set begin operation event
+    if (!::SetEvent(pContext->Cabinet.hBeginOperationEvent))
+    {
+        ExitWithLastError(hr, "Failed to set begin operation event.");
+    }
+
+    // wait for operation to complete
+    hr = WaitForOperation(pContext);
+
+LExit:
+    return hr;
+}
+
+static HRESULT WaitForOperation(
+    __in BURN_CONTAINER_CONTEXT* pContext
+    )
+{
+    HRESULT hr = S_OK;
+    HANDLE rghWait[2] = { };
+
+    // wait for operation complete event
+    rghWait[0] = pContext->Cabinet.hOperationCompleteEvent;
+    rghWait[1] = pContext->Cabinet.hThread;
+    switch (::WaitForMultipleObjects(countof(rghWait), rghWait, FALSE, INFINITE))
+    {
+    case WAIT_OBJECT_0:
+        if (!::ResetEvent(pContext->Cabinet.hOperationCompleteEvent))
+        {
+            ExitWithLastError(hr, "Failed to reset operation complete event.");
+        }
+        break;
+
+    case WAIT_OBJECT_0 + 1:
+        if (!::GetExitCodeThread(pContext->Cabinet.hThread, (DWORD*)&hr))
+        {
+            ExitWithLastError(hr, "Failed to get extraction thread exit code.");
+        }
+        ExitFunction();
+
+    case WAIT_FAILED: __fallthrough;
+    default:
+        ExitWithLastError(hr, "Failed to wait for operation complete event.");
+    }
+
+    // clear operation
+    pContext->Cabinet.operation = BURN_CAB_OPERATION_NONE;
+
+LExit:
+    return hr;
+}
+
+static DWORD WINAPI ExtractThreadProc(
+    __in LPVOID lpThreadParameter
+    )
+{
+    HRESULT hr = S_OK;
+    BURN_CONTAINER_CONTEXT* pContext = (BURN_CONTAINER_CONTEXT*)lpThreadParameter;
+    BOOL fComInitialized = FALSE;
+    HFDI hfdi = NULL;
+    ERF erf = { };
+
+    // initialize COM
+    hr = ::CoInitializeEx(NULL, COINIT_MULTITHREADED);
+    ExitOnFailure(hr, "Failed to initialize COM.");
+    fComInitialized = TRUE;
+
+    // save context in TLS storage
+    vpContext = pContext;
+
+    // create FDI context
+    hfdi = ::FDICreate(CabAlloc, CabFree, CabOpen, CabRead, CabWrite, CabClose, CabSeek, cpuUNKNOWN, &erf);
+    ExitOnNull(hfdi, hr, E_FAIL, "Failed to initialize cabinet.dll.");
+
+    // begin CAB extraction
+    if (!::FDICopy(hfdi, INVALID_CAB_NAME, "", 0, CabNotifyCallback, NULL, NULL))
+    {
+        hr = pContext->Cabinet.hrError;
+        if (E_ABORT == hr || E_NOMOREITEMS == hr)
+        {
+            ExitFunction();
+        }
+        else if (SUCCEEDED(hr))
+        {
+            if (ERROR_SUCCESS != erf.erfType)
+            {
+                hr = HRESULT_FROM_WIN32(erf.erfType);
+            }
+            else
+            {
+                switch (erf.erfOper)
+                {
+                case FDIERROR_NONE:
+                    hr = E_UNEXPECTED;
+                    break;
+                case FDIERROR_CABINET_NOT_FOUND:
+                    hr = HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
+                    break;
+                case FDIERROR_NOT_A_CABINET:
+                    hr = HRESULT_FROM_WIN32(ERROR_INVALID_FUNCTION);
+                    break;
+                case FDIERROR_UNKNOWN_CABINET_VERSION:
+                    hr = HRESULT_FROM_WIN32(ERROR_VERSION_PARSE_ERROR);
+                    break;
+                case FDIERROR_CORRUPT_CABINET:
+                    hr = HRESULT_FROM_WIN32(ERROR_FILE_CORRUPT);
+                    break;
+                case FDIERROR_ALLOC_FAIL:
+                    hr = HRESULT_FROM_WIN32(ERROR_OUTOFMEMORY);
+                    break;
+                case FDIERROR_BAD_COMPR_TYPE:
+                    hr = HRESULT_FROM_WIN32(ERROR_UNSUPPORTED_COMPRESSION);
+                    break;
+                case FDIERROR_MDI_FAIL:
+                    hr = HRESULT_FROM_WIN32(ERROR_BAD_COMPRESSION_BUFFER);
+                    break;
+                case FDIERROR_TARGET_FILE:
+                    hr = HRESULT_FROM_WIN32(ERROR_WRITE_FAULT);
+                    break;
+                case FDIERROR_RESERVE_MISMATCH:
+                    hr = HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
+                    break;
+                case FDIERROR_WRONG_CABINET:
+                    hr = HRESULT_FROM_WIN32(ERROR_DATATYPE_MISMATCH);
+                    break;
+                case FDIERROR_USER_ABORT:
+                    hr = E_ABORT;
+                    break;
+                default:
+                    hr = E_FAIL;
+                    break;
+                }
+            }
+        }
+        ExitOnFailure(hr, "Failed to extract all files from container, erf: %d:%X:%d", erf.fError, erf.erfOper, erf.erfType);
+    }
+
+    // set operation complete event
+    if (!::SetEvent(pContext->Cabinet.hOperationCompleteEvent))
+    {
+        ExitWithLastError(hr, "Failed to set operation complete event.");
+    }
+
+    // wait for begin operation event
+    if (WAIT_FAILED == ::WaitForSingleObject(pContext->Cabinet.hBeginOperationEvent, INFINITE))
+    {
+        ExitWithLastError(hr, "Failed to wait for begin operation event.");
+    }
+
+    if (!::ResetEvent(pContext->Cabinet.hBeginOperationEvent))
+    {
+        ExitWithLastError(hr, "Failed to reset begin operation event.");
+    }
+
+    // read operation
+    switch (pContext->Cabinet.operation)
+    {
+    case BURN_CAB_OPERATION_NEXT_STREAM:
+        ExitFunction1(hr = E_NOMOREITEMS);
+        break;
+
+    case BURN_CAB_OPERATION_CLOSE:
+        ExitFunction1(hr = S_OK);
+
+    default:
+        hr = E_INVALIDSTATE;
+        ExitOnRootFailure(hr, "Invalid operation for this state.");
+    }
+
+LExit:
+    if (hfdi)
+    {
+        ::FDIDestroy(hfdi);
+    }
+    if (fComInitialized)
+    {
+        ::CoUninitialize();
+    }
+
+    return (DWORD)hr;
+}
+
+static INT_PTR DIAMONDAPI CabNotifyCallback(
+    __in FDINOTIFICATIONTYPE iNotification,
+    __inout FDINOTIFICATION *pFDINotify
+    )
+{
+    BURN_CONTAINER_CONTEXT* pContext = vpContext;
+    INT_PTR ipResult = 0; // result to return on success
+
+    switch (iNotification)
+    {
+    case fdintCOPY_FILE:
+        ipResult = CopyFileCallback(pContext, pFDINotify);
+        break;
+
+    case fdintCLOSE_FILE_INFO: // resource extraction complete
+        ipResult = CloseFileInfoCallback(pContext, pFDINotify);
+        break;
+
+    case fdintPARTIAL_FILE: __fallthrough; // no action needed for these messages
+    case fdintNEXT_CABINET: __fallthrough;
+    case fdintENUMERATE: __fallthrough;
+    case fdintCABINET_INFO:
+        break;
+
+    default:
+        AssertSz(FALSE, "CabExtractCallback() - unknown FDI notification command");
+    };
+
+//LExit:
+    return ipResult;
+}
+
+static INT_PTR CopyFileCallback(
+    __in BURN_CONTAINER_CONTEXT* pContext,
+    __inout FDINOTIFICATION* pFDINotify
+    )
+{
+    HRESULT hr = S_OK;
+    INT_PTR ipResult = 1; // result to return on success
+    LPWSTR pwzPath = NULL;
+    LARGE_INTEGER li = { };
+
+    // set operation complete event
+    if (!::SetEvent(pContext->Cabinet.hOperationCompleteEvent))
+    {
+        ExitWithLastError(hr, "Failed to set operation complete event.");
+    }
+
+    // wait for begin operation event
+    if (WAIT_FAILED == ::WaitForSingleObject(pContext->Cabinet.hBeginOperationEvent, INFINITE))
+    {
+        ExitWithLastError(hr, "Failed to wait for begin operation event.");
+    }
+
+    if (!::ResetEvent(pContext->Cabinet.hBeginOperationEvent))
+    {
+        ExitWithLastError(hr, "Failed to reset begin operation event.");
+    }
+
+    // read operation
+    switch (pContext->Cabinet.operation)
+    {
+    case BURN_CAB_OPERATION_NEXT_STREAM:
+        break;
+
+    case BURN_CAB_OPERATION_CLOSE:
+        ExitFunction1(hr = E_ABORT);
+
+    default:
+        hr = E_INVALIDSTATE;
+        ExitOnRootFailure(hr, "Invalid operation for this state.");
+    }
+
+    // copy stream name
+    hr = StrAllocStringAnsi(pContext->Cabinet.psczStreamName, pFDINotify->psz1, 0, CP_UTF8);
+    ExitOnFailure(hr, "Failed to copy stream name: %ls", pFDINotify->psz1);
+
+    // set operation complete event
+    if (!::SetEvent(pContext->Cabinet.hOperationCompleteEvent))
+    {
+        ExitWithLastError(hr, "Failed to set operation complete event.");
+    }
+
+    // wait for begin operation event
+    if (WAIT_FAILED == ::WaitForSingleObject(pContext->Cabinet.hBeginOperationEvent, INFINITE))
+    {
+        ExitWithLastError(hr, "Failed to wait for begin operation event.");
+    }
+
+    if (!::ResetEvent(pContext->Cabinet.hBeginOperationEvent))
+    {
+        ExitWithLastError(hr, "Failed to reset begin operation event.");
+    }
+
+    // read operation
+    switch (pContext->Cabinet.operation)
+    {
+    case BURN_CAB_OPERATION_STREAM_TO_FILE:
+        // create file
+        pContext->Cabinet.hTargetFile = ::CreateFileW(pContext->Cabinet.wzTargetFile, GENERIC_WRITE, FILE_SHARE_READ, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
+        if (INVALID_HANDLE_VALUE == pContext->Cabinet.hTargetFile)
+        {
+            ExitWithLastError(hr, "Failed to create file: %ls", pContext->Cabinet.wzTargetFile);
+        }
+
+        // set file size
+        li.QuadPart = pFDINotify->cb;
+        if (!::SetFilePointerEx(pContext->Cabinet.hTargetFile, li, NULL, FILE_BEGIN))
+        {
+            ExitWithLastError(hr, "Failed to set file pointer to end of file.");
+        }
+
+        if (!::SetEndOfFile(pContext->Cabinet.hTargetFile))
+        {
+            ExitWithLastError(hr, "Failed to set end of file.");
+        }
+
+        li.QuadPart = 0;
+        if (!::SetFilePointerEx(pContext->Cabinet.hTargetFile, li, NULL, FILE_BEGIN))
+        {
+            ExitWithLastError(hr, "Failed to set file pointer to beginning of file.");
+        }
+
+        break;
+
+    case BURN_CAB_OPERATION_STREAM_TO_BUFFER:
+        // allocate buffer for stream
+        pContext->Cabinet.pbTargetBuffer = (BYTE*)MemAlloc(pFDINotify->cb, TRUE);
+        ExitOnNull(pContext->Cabinet.pbTargetBuffer, hr, E_OUTOFMEMORY, "Failed to allocate buffer for stream.");
+
+        // set buffer size and write position
+        pContext->Cabinet.cbTargetBuffer = pFDINotify->cb;
+        pContext->Cabinet.iTargetBuffer = 0;
+
+        break;
+
+    case BURN_CAB_OPERATION_SKIP_STREAM:
+        ipResult = 0;
+        break;
+
+    case BURN_CAB_OPERATION_CLOSE:
+        ExitFunction1(hr = E_ABORT);
+
+    default:
+        hr = E_INVALIDSTATE;
+        ExitOnRootFailure(hr, "Invalid operation for this state.");
+    }
+
+LExit:
+    ReleaseStr(pwzPath);
+
+    pContext->Cabinet.hrError = hr;
+    return SUCCEEDED(hr) ? ipResult : -1;
+}
+
+static INT_PTR CloseFileInfoCallback(
+    __in BURN_CONTAINER_CONTEXT* pContext,
+    __inout FDINOTIFICATION *pFDINotify
+    )
+{
+    HRESULT hr = S_OK;
+    INT_PTR ipResult = 1; // result to return on success
+    FILETIME ftLocal = { };
+    FILETIME ft = { };
+
+    // read operation
+    switch (pContext->Cabinet.operation)
+    {
+    case BURN_CAB_OPERATION_STREAM_TO_FILE:
+        // Make a best effort to set the time on the new file before
+        // we close it.
+        if (::DosDateTimeToFileTime(pFDINotify->date, pFDINotify->time, &ftLocal))
+        {
+            if (::LocalFileTimeToFileTime(&ftLocal, &ft))
+            {
+                ::SetFileTime(pContext->Cabinet.hTargetFile, &ft, &ft, &ft);
+            }
+        }
+
+        // close file
+        ReleaseFile(pContext->Cabinet.hTargetFile);
+        break;
+
+    case BURN_CAB_OPERATION_STREAM_TO_BUFFER:
+        break;
+
+    case BURN_CAB_OPERATION_CLOSE:
+        ExitFunction1(hr = E_ABORT);
+
+    default:
+        hr = E_INVALIDSTATE;
+        ExitOnRootFailure(hr, "Invalid operation for this state.");
+    }
+
+    //if (pContext->pfnProgress)
+    //{
+    //    hr = StrAllocFormatted(&pwzPath, L"%s%ls", pContext->wzRootPath, pFDINotify->psz1);
+    //    ExitOnFailure(hr, "Failed to calculate file path from: %ls and %s", pContext->wzRootPath, pFDINotify->psz1);
+    //    if (SUCCEEDED(hr))
+    //    {
+    //        hr = pContext->pfnProgress(BOX_PROGRESS_DECOMPRESSION_END, pwzPath, 0, pContext->pvContext);
+    //        if (S_OK != hr)
+    //        {
+    //            pContext->hrError = hr;
+    //            ExitFunction();
+    //        }
+    //    }
+    //}
+
+LExit:
+    pContext->Cabinet.hrError = hr;
+    return SUCCEEDED(hr) ? ipResult : -1;
+}
+
+static LPVOID DIAMONDAPI CabAlloc(
+    __in DWORD dwSize
+    )
+{
+    return MemAlloc(dwSize, FALSE);
+}
+
+static void DIAMONDAPI CabFree(
+    __in LPVOID pvData
+    )
+{
+    MemFree(pvData);
+}
+
+static INT_PTR FAR DIAMONDAPI CabOpen(
+    __in char FAR * pszFile,
+    __in int /* oflag */,
+    __in int /* pmode */
+    )
+{
+    HRESULT hr = S_OK;
+    BURN_CONTAINER_CONTEXT* pContext = vpContext;
+    HANDLE hFile = INVALID_HANDLE_VALUE;
+
+    // If this is the invalid cab name, use our file handle.
+    if (CSTR_EQUAL == ::CompareStringA(LOCALE_NEUTRAL, 0, INVALID_CAB_NAME, -1, pszFile, -1))
+    {
+        if (!::DuplicateHandle(::GetCurrentProcess(), pContext->hFile, ::GetCurrentProcess(), &hFile, 0, FALSE, DUPLICATE_SAME_ACCESS))
+        {
+            ExitWithLastError(hr, "Failed to duplicate handle to cab container.");
+        }
+
+        // Use a virtual file pointer since duplicated file handles share their file pointer. Seek to container offset
+        // to start.
+        hr = AddVirtualFilePointer(&pContext->Cabinet, hFile, pContext->qwOffset);
+        ExitOnFailure(hr, "Failed to add virtual file pointer for cab container.");
+    }
+    else // open file requested. This is used in the rare cases where the CAB API wants to create a temp file.
+    {
+        hFile = ::CreateFileA(pszFile, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN, NULL);
+        ExitOnInvalidHandleWithLastError(hFile, hr, "Failed to open cabinet file: %hs", pszFile);
+    }
+
+LExit:
+    pContext->Cabinet.hrError = hr;
+    return FAILED(hr) ? -1 : (INT_PTR)hFile;
+}
+
+static UINT FAR DIAMONDAPI CabRead(
+    __in INT_PTR hf,
+    __out void FAR *pv,
+    __in UINT cb
+    )
+{
+    HRESULT hr = S_OK;
+    BURN_CONTAINER_CONTEXT* pContext = vpContext;
+    HANDLE hFile = (HANDLE)hf;
+    DWORD cbRead = 0;
+
+    ReadIfVirtualFilePointer(&pContext->Cabinet, hFile, cb);
+
+    if (!::ReadFile(hFile, pv, cb, &cbRead, NULL))
+    {
+        ExitWithLastError(hr, "Failed to read during cabinet extraction.");
+    }
+
+LExit:
+    pContext->Cabinet.hrError = hr;
+    return FAILED(hr) ? -1 : cbRead;
+}
+
+static UINT FAR DIAMONDAPI CabWrite(
+    __in INT_PTR /* hf */,
+    __in void FAR *pv,
+    __in UINT cb
+    )
+{
+    HRESULT hr = S_OK;
+    BURN_CONTAINER_CONTEXT* pContext = vpContext;
+    DWORD cbWrite = 0;
+
+    switch (pContext->Cabinet.operation)
+    {
+    case BURN_CAB_OPERATION_STREAM_TO_FILE:
+        // write file
+        if (!::WriteFile(pContext->Cabinet.hTargetFile, pv, cb, &cbWrite, NULL))
+        {
+            ExitWithLastError(hr, "Failed to write during cabinet extraction.");
+        }
+        break;
+
+    case BURN_CAB_OPERATION_STREAM_TO_BUFFER:
+        // copy to target buffer
+        memcpy_s(pContext->Cabinet.pbTargetBuffer + pContext->Cabinet.iTargetBuffer, pContext->Cabinet.cbTargetBuffer - pContext->Cabinet.iTargetBuffer, pv, cb);
+        pContext->Cabinet.iTargetBuffer += cb;
+
+        cbWrite = cb;
+        break;
+
+    default:
+        hr = E_INVALIDSTATE;
+        ExitOnFailure(hr, "Unexpected call to CabWrite().");
+    }
+
+LExit:
+    pContext->Cabinet.hrError = hr;
+    return FAILED(hr) ? -1 : cbWrite;
+}
+
+static long FAR DIAMONDAPI CabSeek(
+    __in INT_PTR hf,
+    __in long dist,
+    __in int seektype
+    )
+{
+    HRESULT hr = S_OK;
+    BURN_CONTAINER_CONTEXT* pContext = vpContext;
+    HANDLE hFile = (HANDLE)hf;
+    LARGE_INTEGER liDistance = { };
+    LARGE_INTEGER liNewPointer = { };
+    DWORD dwSeekType = 0;
+
+    // We assume that CabSeek() will only be called to seek the
+    // cabinet itself so we have to offset the seek operations to
+    // where the internal cabinet starts.
+    switch (seektype)
+    {
+    case FILE_BEGIN:
+        liDistance.QuadPart = pContext->qwOffset + dist;
+        dwSeekType = FILE_BEGIN;
+        break;
+
+    case FILE_CURRENT:
+        liDistance.QuadPart = dist;
+        dwSeekType = FILE_CURRENT;
+        break;
+
+    case FILE_END:
+        liDistance.QuadPart = pContext->qwOffset + pContext->qwSize + dist;
+        dwSeekType = FILE_BEGIN;
+        break;
+
+    default:
+        hr = E_INVALIDARG;
+        ExitOnFailure(hr, "Invalid seek type.");;
+    }
+
+    if (SetIfVirtualFilePointer(&pContext->Cabinet, hFile, liDistance.QuadPart, &liNewPointer.QuadPart, seektype))
+    {
+        // set file pointer
+        if (!::SetFilePointerEx(hFile, liDistance, &liNewPointer, seektype))
+        {
+            ExitWithLastError(hr, "Failed to move file pointer 0x%x bytes.", dist);
+        }
+    }
+
+    liNewPointer.QuadPart -= pContext->qwOffset;
+
+LExit:
+    pContext->Cabinet.hrError = hr;
+    return FAILED(hr) ? -1 : liNewPointer.LowPart;
+}
+
+static int FAR DIAMONDAPI CabClose(
+    __in INT_PTR hf
+    )
+{
+    BURN_CONTAINER_CONTEXT* pContext = vpContext;
+    HANDLE hFile = (HANDLE)hf;
+
+    CloseIfVirturalFilePointer(&pContext->Cabinet, hFile);
+    ReleaseFileHandle(hFile);
+
+    return 0;
+}
+
+static HRESULT AddVirtualFilePointer(
+    __in BURN_CONTAINER_CONTEXT_CABINET* pCabinetContext,
+    __in HANDLE hFile,
+    __in LONGLONG llInitialFilePointer
+    )
+{
+    HRESULT hr = S_OK;
+
+    hr = MemEnsureArraySize(reinterpret_cast<LPVOID*>(&pCabinetContext->rgVirtualFilePointers), pCabinetContext->cVirtualFilePointers, sizeof(BURN_CONTAINER_CONTEXT_CABINET_VIRTUAL_FILE_POINTER), ARRAY_GROWTH_SIZE);
+    ExitOnFailure(hr, "Failed to allocate memory for the virtual file pointer array.");
+
+    pCabinetContext->rgVirtualFilePointers[pCabinetContext->cVirtualFilePointers].hFile = hFile;
+    pCabinetContext->rgVirtualFilePointers[pCabinetContext->cVirtualFilePointers].liPosition.QuadPart = llInitialFilePointer;
+    ++pCabinetContext->cVirtualFilePointers;
+
+LExit:
+    return hr;
+}
+
+static HRESULT ReadIfVirtualFilePointer(
+    __in BURN_CONTAINER_CONTEXT_CABINET* pCabinetContext,
+    __in HANDLE hFile,
+    __in DWORD cbRead
+    )
+{
+    HRESULT hr = E_NOTFOUND;
+
+    BURN_CONTAINER_CONTEXT_CABINET_VIRTUAL_FILE_POINTER* pVfp = GetVirtualFilePointer(pCabinetContext, hFile);
+    if (pVfp)
+    {
+        // Set the file handle to the virtual file pointer.
+        if (!::SetFilePointerEx(hFile, pVfp->liPosition, NULL, FILE_BEGIN))
+        {
+            ExitWithLastError(hr, "Failed to move to virtual file pointer.");
+        }
+
+        pVfp->liPosition.QuadPart += cbRead; // add the amount that will be read to advance the pointer.
+        hr = S_OK;
+    }
+
+LExit:
+    return hr;
+}
+
+static BOOL SetIfVirtualFilePointer(
+    __in BURN_CONTAINER_CONTEXT_CABINET* pCabinetContext,
+    __in HANDLE hFile,
+    __in LONGLONG llDistance,
+    __out LONGLONG* pllNewPostion,
+    __in DWORD dwSeekType
+    )
+{
+    BOOL fFound = FALSE;
+
+    BURN_CONTAINER_CONTEXT_CABINET_VIRTUAL_FILE_POINTER* pVfp = GetVirtualFilePointer(pCabinetContext, hFile);
+    if (pVfp)
+    {
+        switch (dwSeekType)
+        {
+        case FILE_BEGIN:
+            pVfp->liPosition.QuadPart = llDistance;
+            break;
+
+        case FILE_CURRENT:
+            pVfp->liPosition.QuadPart += llDistance;
+            break;
+
+        case FILE_END: __fallthrough;
+        default:
+            AssertSz(FALSE, "Unsupported seek type.");
+            break;
+        }
+
+        *pllNewPostion = pVfp->liPosition.QuadPart;
+        fFound = TRUE;
+    }
+
+    return fFound;
+}
+
+static HRESULT CloseIfVirturalFilePointer(
+    __in BURN_CONTAINER_CONTEXT_CABINET* pCabinetContext,
+    __in HANDLE hFile
+    )
+{
+    HRESULT hr = E_NOTFOUND;
+
+    BURN_CONTAINER_CONTEXT_CABINET_VIRTUAL_FILE_POINTER* pVfp = GetVirtualFilePointer(pCabinetContext, hFile);
+    if (pVfp)
+    {
+        pVfp->hFile = INVALID_HANDLE_VALUE;
+        pVfp->liPosition.QuadPart = 0;
+        hr = S_OK;
+    }
+
+    return hr;
+}
+
+static BURN_CONTAINER_CONTEXT_CABINET_VIRTUAL_FILE_POINTER* GetVirtualFilePointer(
+    __in BURN_CONTAINER_CONTEXT_CABINET* pCabinetContext,
+    __in HANDLE hFile
+    )
+{
+    for (DWORD i = 0; i < pCabinetContext->cVirtualFilePointers; ++i)
+    {
+        BURN_CONTAINER_CONTEXT_CABINET_VIRTUAL_FILE_POINTER* pVfp = pCabinetContext->rgVirtualFilePointers + i;
+        if (pVfp->hFile == hFile)
+        {
+            return pVfp;
+        }
+    }
+
+    return NULL;
+}
diff --git a/src/engine/cabextract.h b/src/engine/cabextract.h
new file mode 100644
index 00000000..31667f2b
--- /dev/null
+++ b/src/engine/cabextract.h
@@ -0,0 +1,40 @@
+#pragma once
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+
+// function declarations
+
+void CabExtractInitialize();
+HRESULT CabExtractOpen(
+    __in BURN_CONTAINER_CONTEXT* pContext,
+    __in LPCWSTR wzFilePath
+    );
+HRESULT CabExtractNextStream(
+    __in BURN_CONTAINER_CONTEXT* pContext,
+    __inout_z LPWSTR* psczStreamName
+    );
+HRESULT CabExtractStreamToFile(
+    __in BURN_CONTAINER_CONTEXT* pContext,
+    __in_z LPCWSTR wzFileName
+    );
+HRESULT CabExtractStreamToBuffer(
+    __in BURN_CONTAINER_CONTEXT* pContext,
+    __out BYTE** ppbBuffer,
+    __out SIZE_T* pcbBuffer
+    );
+HRESULT CabExtractSkipStream(
+    __in BURN_CONTAINER_CONTEXT* pContext
+    );
+HRESULT CabExtractClose(
+    __in BURN_CONTAINER_CONTEXT* pContext
+    );
+
+
+#if defined(__cplusplus)
+}
+#endif
diff --git a/src/engine/cache.cpp b/src/engine/cache.cpp
new file mode 100644
index 00000000..9338426d
--- /dev/null
+++ b/src/engine/cache.cpp
@@ -0,0 +1,2026 @@
+// 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.
+
+#include "precomp.h"
+
+static const LPCWSTR BUNDLE_CLEAN_ROOM_WORKING_FOLDER_NAME = L".cr";
+static const LPCWSTR BUNDLE_WORKING_FOLDER_NAME = L".be";
+static const LPCWSTR UNVERIFIED_CACHE_FOLDER_NAME = L".unverified";
+static const LPCWSTR PACKAGE_CACHE_FOLDER_NAME = L"Package Cache";
+static const DWORD FILE_OPERATION_RETRY_COUNT = 3;
+static const DWORD FILE_OPERATION_RETRY_WAIT = 2000;
+
+static BOOL vfInitializedCache = FALSE;
+static BOOL vfRunningFromCache = FALSE;
+static LPWSTR vsczSourceProcessPath = NULL;
+static LPWSTR vsczWorkingFolder = NULL;
+static LPWSTR vsczDefaultUserPackageCache = NULL;
+static LPWSTR vsczDefaultMachinePackageCache = NULL;
+static LPWSTR vsczCurrentMachinePackageCache = NULL;
+
+static HRESULT CalculateWorkingFolder(
+    __in_z LPCWSTR wzBundleId,
+    __deref_out_z LPWSTR* psczWorkingFolder
+    );
+static HRESULT GetLastUsedSourceFolder(
+    __in BURN_VARIABLES* pVariables,
+    __out_z LPWSTR* psczLastSource
+    );
+static HRESULT CreateCompletedPath(
+    __in BOOL fPerMachine,
+    __in LPCWSTR wzCacheId,
+    __out LPWSTR* psczCacheDirectory
+    );
+static HRESULT CreateUnverifiedPath(
+    __in BOOL fPerMachine,
+    __in_z LPCWSTR wzPayloadId,
+    __out_z LPWSTR* psczUnverifiedPayloadPath
+    );
+static HRESULT GetRootPath(
+    __in BOOL fPerMachine,
+    __in BOOL fAllowRedirect,
+    __deref_out_z LPWSTR* psczRootPath
+    );
+static HRESULT VerifyThenTransferContainer(
+    __in BURN_CONTAINER* pContainer,
+    __in_z LPCWSTR wzCachedPath,
+    __in_z LPCWSTR wzUnverifiedContainerPath,
+    __in BOOL fMove
+    );
+static HRESULT VerifyThenTransferPayload(
+    __in BURN_PAYLOAD* pPayload,
+    __in_z LPCWSTR wzCachedPath,
+    __in_z LPCWSTR wzUnverifiedPayloadPath,
+    __in BOOL fMove
+    );
+static HRESULT TransferWorkingPathToUnverifiedPath(
+    __in_z LPCWSTR wzWorkingPath,
+    __in_z LPCWSTR wzUnverifiedPayloadPath,
+    __in BOOL fMove
+    );
+static HRESULT VerifyFileAgainstPayload(
+    __in BURN_PAYLOAD* pPayload,
+    __in_z LPCWSTR wzVerifyPath
+    );
+static HRESULT ResetPathPermissions(
+    __in BOOL fPerMachine,
+    __in_z LPCWSTR wzPath
+    );
+static HRESULT SecurePath(
+    __in LPCWSTR wzPath
+    );
+static HRESULT CopyEngineToWorkingFolder(
+    __in_z LPCWSTR wzSourcePath,
+    __in_z LPCWSTR wzWorkingFolderName,
+    __in_z LPCWSTR wzExecutableName,
+    __in BURN_PAYLOADS* pUxPayloads,
+    __in BURN_SECTION* pSection,
+    __deref_out_z_opt LPWSTR* psczEngineWorkingPath
+    );
+static HRESULT CopyEngineWithSignatureFixup(
+    __in HANDLE hEngineFile,
+    __in_z LPCWSTR wzEnginePath,
+    __in_z LPCWSTR wzTargetPath,
+    __in BURN_SECTION* pSection
+    );
+static HRESULT RemoveBundleOrPackage(
+    __in BOOL fBundle,
+    __in BOOL fPerMachine,
+    __in_z LPCWSTR wzBundleOrPackageId,
+    __in_z LPCWSTR wzCacheId
+    );
+static HRESULT VerifyHash(
+    __in BYTE* pbHash,
+    __in DWORD cbHash,
+    __in_z LPCWSTR wzUnverifiedPayloadPath,
+    __in HANDLE hFile
+    );
+static HRESULT VerifyPayloadWithCatalog(
+    __in BURN_PAYLOAD* pPayload,
+    __in_z LPCWSTR wzUnverifiedPayloadPath,
+    __in HANDLE hFile
+    );
+static HRESULT VerifyPayloadAgainstChain(
+    __in BURN_PAYLOAD* pPayload,
+    __in PCCERT_CHAIN_CONTEXT pChainContext
+    );
+
+
+extern "C" HRESULT CacheInitialize(
+    __in BURN_REGISTRATION* pRegistration,
+    __in BURN_VARIABLES* pVariables,
+    __in_z_opt LPCWSTR wzSourceProcessPath
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR sczCurrentPath = NULL;
+    LPWSTR sczCompletedFolder = NULL;
+    LPWSTR sczCompletedPath = NULL;
+    LPWSTR sczOriginalSource = NULL;
+    LPWSTR sczOriginalSourceFolder = NULL;
+    int nCompare = 0;
+
+    if (!vfInitializedCache)
+    {
+        hr = PathForCurrentProcess(&sczCurrentPath, NULL);
+        ExitOnFailure(hr, "Failed to get current process path.");
+
+        // Determine if we are running from the package cache or not.
+        hr = CacheGetCompletedPath(pRegistration->fPerMachine, pRegistration->sczId, &sczCompletedFolder);
+        ExitOnFailure(hr, "Failed to get completed path for bundle.");
+
+        hr = PathConcat(sczCompletedFolder, pRegistration->sczExecutableName, &sczCompletedPath);
+        ExitOnFailure(hr, "Failed to combine working path with engine file name.");
+
+        hr = PathCompare(sczCurrentPath, sczCompletedPath, &nCompare);
+        ExitOnFailure(hr, "Failed to compare current path for bundle: %ls", sczCurrentPath);
+
+        vfRunningFromCache = (CSTR_EQUAL == nCompare);
+
+        // If a source process path was not provided (e.g. we are not being
+        // run in a clean room) then use the current process path as the
+        // source process path.
+        if (!wzSourceProcessPath)
+        {
+            wzSourceProcessPath = sczCurrentPath;
+        }
+
+        hr = StrAllocString(&vsczSourceProcessPath, wzSourceProcessPath, 0);
+        ExitOnFailure(hr, "Failed to initialize cache source path.");
+
+        // If we're not running from the cache, ensure the original source is set.
+        if (!vfRunningFromCache)
+        {
+            // If the original source has not been set already then set it where the bundle is
+            // running from right now. This value will be persisted and we'll use it when launched
+            // from the clean room or package cache since none of our packages will be relative to
+            // those locations.
+            hr = VariableGetString(pVariables, BURN_BUNDLE_ORIGINAL_SOURCE, &sczOriginalSource);
+            if (E_NOTFOUND == hr)
+            {
+                hr = VariableSetLiteralString(pVariables, BURN_BUNDLE_ORIGINAL_SOURCE, wzSourceProcessPath, FALSE);
+                ExitOnFailure(hr, "Failed to set original source variable.");
+
+                hr = StrAllocString(&sczOriginalSource, wzSourceProcessPath, 0);
+                ExitOnFailure(hr, "Failed to copy current path to original source.");
+            }
+
+            hr = VariableGetString(pVariables, BURN_BUNDLE_ORIGINAL_SOURCE_FOLDER, &sczOriginalSourceFolder);
+            if (E_NOTFOUND == hr)
+            {
+                hr = PathGetDirectory(sczOriginalSource, &sczOriginalSourceFolder);
+                ExitOnFailure(hr, "Failed to get directory from original source path.");
+
+                hr = VariableSetLiteralString(pVariables, BURN_BUNDLE_ORIGINAL_SOURCE_FOLDER, sczOriginalSourceFolder, FALSE);
+                ExitOnFailure(hr, "Failed to set original source directory variable.");
+            }
+        }
+
+        vfInitializedCache = TRUE;
+    }
+
+LExit:
+    ReleaseStr(sczCurrentPath);
+    ReleaseStr(sczCompletedFolder);
+    ReleaseStr(sczCompletedPath);
+    ReleaseStr(sczOriginalSource);
+    ReleaseStr(sczOriginalSourceFolder);
+
+    return hr;
+}
+
+extern "C" HRESULT CacheEnsureWorkingFolder(
+    __in_z LPCWSTR wzBundleId,
+    __deref_out_z_opt LPWSTR* psczWorkingFolder
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR sczWorkingFolder = NULL;
+
+    hr = CalculateWorkingFolder(wzBundleId, &sczWorkingFolder);
+    ExitOnFailure(hr, "Failed to calculate working folder to ensure it exists.");
+
+    hr = DirEnsureExists(sczWorkingFolder, NULL);
+    ExitOnFailure(hr, "Failed create working folder.");
+
+    // Best effort to ensure our working folder is not encrypted.
+    ::DecryptFileW(sczWorkingFolder, 0);
+
+    if (psczWorkingFolder)
+    {
+        hr = StrAllocString(psczWorkingFolder, sczWorkingFolder, 0);
+        ExitOnFailure(hr, "Failed to copy working folder.");
+    }
+
+LExit:
+    ReleaseStr(sczWorkingFolder);
+
+    return hr;
+}
+
+extern "C" HRESULT CacheCalculateBundleWorkingPath(
+    __in_z LPCWSTR wzBundleId,
+    __in LPCWSTR wzExecutableName,
+    __deref_out_z LPWSTR* psczWorkingPath
+    )
+{
+    Assert(vfInitializedCache);
+
+    HRESULT hr = S_OK;
+    LPWSTR sczWorkingFolder = NULL;
+
+    // If the bundle is running out of the package cache then we use that as the
+    // working folder since we feel safe in the package cache.
+    if (vfRunningFromCache)
+    {
+        hr = PathForCurrentProcess(psczWorkingPath, NULL);
+        ExitOnFailure(hr, "Failed to get current process path.");
+    }
+    else // Otherwise, use the real working folder.
+    {
+        hr = CalculateWorkingFolder(wzBundleId, &sczWorkingFolder);
+        ExitOnFailure(hr, "Failed to get working folder for bundle.");
+
+        hr = StrAllocFormatted(psczWorkingPath, L"%ls%ls\\%ls", sczWorkingFolder, BUNDLE_WORKING_FOLDER_NAME, wzExecutableName);
+        ExitOnFailure(hr, "Failed to calculate the bundle working path.");
+    }
+
+LExit:
+    ReleaseStr(sczWorkingFolder);
+
+    return hr;
+}
+
+extern "C" HRESULT CacheCalculateBundleLayoutWorkingPath(
+    __in_z LPCWSTR wzBundleId,
+    __deref_out_z LPWSTR* psczWorkingPath
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR sczWorkingFolder = NULL;
+
+    hr = CalculateWorkingFolder(wzBundleId, psczWorkingPath);
+    ExitOnFailure(hr, "Failed to get working folder for bundle layout.");
+
+    hr = StrAllocConcat(psczWorkingPath, wzBundleId, 0);
+    ExitOnFailure(hr, "Failed to append bundle id for bundle layout working path.");
+
+LExit:
+    ReleaseStr(sczWorkingFolder);
+
+    return hr;
+}
+
+extern "C" HRESULT CacheCalculatePayloadWorkingPath(
+    __in_z LPCWSTR wzBundleId,
+    __in BURN_PAYLOAD* pPayload,
+    __deref_out_z LPWSTR* psczWorkingPath
+    )
+{
+    HRESULT hr = S_OK;
+
+    hr = CalculateWorkingFolder(wzBundleId, psczWorkingPath);
+    ExitOnFailure(hr, "Failed to get working folder for payload.");
+
+    hr = StrAllocConcat(psczWorkingPath, pPayload->sczKey, 0);
+    ExitOnFailure(hr, "Failed to append SHA1 hash as payload unverified path.");
+
+LExit:
+    return hr;
+}
+
+extern "C" HRESULT CacheCalculateContainerWorkingPath(
+    __in_z LPCWSTR wzBundleId,
+    __in BURN_CONTAINER* pContainer,
+    __deref_out_z LPWSTR* psczWorkingPath
+    )
+{
+    HRESULT hr = S_OK;
+
+    hr = CalculateWorkingFolder(wzBundleId, psczWorkingPath);
+    ExitOnFailure(hr, "Failed to get working folder for container.");
+
+    hr = StrAllocConcat(psczWorkingPath, pContainer->sczHash, 0);
+    ExitOnFailure(hr, "Failed to append SHA1 hash as container unverified path.");
+
+LExit:
+    return hr;
+}
+
+extern "C" HRESULT CacheGetRootCompletedPath(
+    __in BOOL fPerMachine,
+    __in BOOL fForceInitialize,
+    __deref_out_z LPWSTR* psczRootCompletedPath
+    )
+{
+    HRESULT hr = S_OK;
+
+    if (fForceInitialize)
+    {
+        hr = CreateCompletedPath(fPerMachine, L"", psczRootCompletedPath);
+    }
+    else
+    {
+        hr = GetRootPath(fPerMachine, TRUE, psczRootCompletedPath);
+    }
+
+    return hr;
+}
+
+extern "C" HRESULT CacheGetCompletedPath(
+    __in BOOL fPerMachine,
+    __in_z LPCWSTR wzCacheId,
+    __deref_out_z LPWSTR* psczCompletedPath
+    )
+{
+    HRESULT hr = S_OK;
+    BOOL fRedirected = FALSE;
+    LPWSTR sczRootPath = NULL;
+    LPWSTR sczCurrentCompletedPath = NULL;
+    LPWSTR sczDefaultCompletedPath = NULL;
+
+    hr = GetRootPath(fPerMachine, TRUE, &sczRootPath);
+    ExitOnFailure(hr, "Failed to get %hs package cache root directory.", fPerMachine ? "per-machine" : "per-user");
+
+    // GetRootPath returns S_FALSE if the package cache is redirected elsewhere.
+    fRedirected = S_FALSE == hr;
+
+    hr = PathConcat(sczRootPath, wzCacheId, &sczCurrentCompletedPath);
+    ExitOnFailure(hr, "Failed to construct cache path.");
+
+    hr = PathBackslashTerminate(&sczCurrentCompletedPath);
+    ExitOnFailure(hr, "Failed to ensure cache path was backslash terminated.");
+
+    // Return the old package cache directory if the new directory does not exist but the old directory does.
+    // If neither package cache directory exists return the (possibly) redirected package cache directory.
+    if (fRedirected && !DirExists(sczCurrentCompletedPath, NULL))
+    {
+        hr = GetRootPath(fPerMachine, FALSE, &sczRootPath);
+        ExitOnFailure(hr, "Failed to get old %hs package cache root directory.", fPerMachine ? "per-machine" : "per-user");
+
+        hr = PathConcat(sczRootPath, wzCacheId, &sczDefaultCompletedPath);
+        ExitOnFailure(hr, "Failed to construct cache path.");
+
+        hr = PathBackslashTerminate(&sczDefaultCompletedPath);
+        ExitOnFailure(hr, "Failed to ensure cache path was backslash terminated.");
+
+        if (DirExists(sczDefaultCompletedPath, NULL))
+        {
+            *psczCompletedPath = sczDefaultCompletedPath;
+            sczDefaultCompletedPath = NULL;
+
+            ExitFunction();
+        }
+    }
+
+    *psczCompletedPath = sczCurrentCompletedPath;
+    sczCurrentCompletedPath = NULL;
+
+LExit:
+    ReleaseNullStr(sczDefaultCompletedPath);
+    ReleaseNullStr(sczCurrentCompletedPath);
+    ReleaseNullStr(sczRootPath);
+
+    return hr;
+}
+
+extern "C" HRESULT CacheGetResumePath(
+    __in_z LPCWSTR wzPayloadWorkingPath,
+    __deref_out_z LPWSTR* psczResumePath
+    )
+{
+    HRESULT hr = S_OK;
+
+    hr = StrAllocFormatted(psczResumePath, L"%ls.R", wzPayloadWorkingPath);
+    ExitOnFailure(hr, "Failed to create resume path.");
+
+LExit:
+    return hr;
+}
+
+extern "C" HRESULT CacheFindLocalSource(
+    __in_z LPCWSTR wzSourcePath,
+    __in BURN_VARIABLES* pVariables,
+    __out BOOL* pfFound,
+    __out_z LPWSTR* psczSourceFullPath
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR sczSourceProcessFolder = NULL;
+    LPWSTR sczCurrentPath = NULL;
+    LPWSTR sczLastSourcePath = NULL;
+    LPWSTR sczLastSourceFolder = NULL;
+    LPWSTR sczLayoutPath = NULL;
+    LPWSTR sczLayoutFolder = NULL;
+    LPCWSTR rgwzSearchPaths[3] = { };
+    DWORD cSearchPaths = 0;
+
+    // If the source path provided is a full path, obviously that is where we should be looking.
+    if (PathIsAbsolute(wzSourcePath))
+    {
+        rgwzSearchPaths[0] = wzSourcePath;
+        cSearchPaths = 1;
+    }
+    else
+    {
+        // If we're not running from cache or we couldn't get the last source, use
+        // the source path location first. In the case where we are in the bundle's
+        // package cache and couldn't find a last used source we unfortunately will
+        // be picking the package cache path which isn't likely to have what we are
+        // looking for.
+        hr = GetLastUsedSourceFolder(pVariables, &sczLastSourceFolder);
+        if (!vfRunningFromCache || FAILED(hr))
+        {
+            hr = PathGetDirectory(vsczSourceProcessPath, &sczSourceProcessFolder);
+            ExitOnFailure(hr, "Failed to get current process directory.");
+
+            hr = PathConcat(sczSourceProcessFolder, wzSourcePath, &sczCurrentPath);
+            ExitOnFailure(hr, "Failed to combine last source with source.");
+
+            rgwzSearchPaths[0] = sczCurrentPath;
+            cSearchPaths = 1;
+        }
+
+        // If we have a last used source and it does not duplicate the existing search path,
+        // add the last used source to the search path second.
+        if (sczLastSourceFolder && *sczLastSourceFolder)
+        {
+            hr = PathConcat(sczLastSourceFolder, wzSourcePath, &sczLastSourcePath);
+            ExitOnFailure(hr, "Failed to combine last source with source.");
+
+            if (0 == cSearchPaths || CSTR_EQUAL != ::CompareStringW(LOCALE_NEUTRAL, NORM_IGNORECASE, rgwzSearchPaths[0], -1, sczLastSourcePath, -1))
+            {
+                rgwzSearchPaths[cSearchPaths] = sczLastSourcePath;
+                ++cSearchPaths;
+            }
+        }
+
+        // Also consider the layout directory if set on the command line or by the BA.
+        hr = VariableGetString(pVariables, BURN_BUNDLE_LAYOUT_DIRECTORY, &sczLayoutFolder);
+        if (E_NOTFOUND != hr)
+        {
+            ExitOnFailure(hr, "Failed to get bundle layout directory property.");
+
+            hr = PathConcat(sczLayoutFolder, wzSourcePath, &sczLayoutPath);
+            ExitOnFailure(hr, "Failed to combine layout source with source.");
+
+            rgwzSearchPaths[cSearchPaths] = sczLayoutPath;
+            ++cSearchPaths;
+        }
+    }
+
+    *pfFound = FALSE; // assume we won't find the file locally.
+
+    for (DWORD i = 0; i < cSearchPaths; ++i)
+    {
+        // If the file exists locally, copy its path.
+        if (FileExistsEx(rgwzSearchPaths[i], NULL))
+        {
+            hr = StrAllocString(psczSourceFullPath, rgwzSearchPaths[i], 0);
+            ExitOnFailure(hr, "Failed to copy source path.");
+
+            *pfFound = TRUE;
+            break;
+        }
+    }
+
+    // If nothing was found, return the first thing in our search path as the
+    // best path where we thought we should have found the file.
+    if (!*pfFound)
+    {
+        hr = StrAllocString(psczSourceFullPath, rgwzSearchPaths[0], 0);
+        ExitOnFailure(hr, "Failed to copy source path.");
+    }
+
+LExit:
+    ReleaseStr(sczCurrentPath);
+    ReleaseStr(sczSourceProcessFolder);
+    ReleaseStr(sczLastSourceFolder);
+    ReleaseStr(sczLastSourcePath);
+    ReleaseStr(sczLayoutFolder);
+    ReleaseStr(sczLayoutPath);
+
+    return hr;
+}
+
+extern "C" HRESULT CacheSetLastUsedSource(
+    __in BURN_VARIABLES* pVariables,
+    __in_z LPCWSTR wzSourcePath,
+    __in_z LPCWSTR wzRelativePath
+    )
+{
+    HRESULT hr = S_OK;
+    size_t cchSourcePath = 0;
+    size_t cchRelativePath = 0;
+    size_t iSourceRelativePath = 0;
+    LPWSTR sczSourceFolder = NULL;
+    LPWSTR sczLastSourceFolder = NULL;
+    int nCompare = 0;
+
+    hr = ::StringCchLengthW(wzSourcePath, STRSAFE_MAX_CCH, &cchSourcePath);
+    ExitOnFailure(hr, "Failed to determine length of source path.");
+
+    hr = ::StringCchLengthW(wzRelativePath, STRSAFE_MAX_CCH, &cchRelativePath);
+    ExitOnFailure(hr, "Failed to determine length of relative path.");
+
+    // If the source path is smaller than the relative path (plus space for "X:\") then we know they
+    // are not relative to each other.
+    if (cchSourcePath < cchRelativePath + 3)
+    {
+        ExitFunction();
+    }
+
+    // If the source path ends with the relative path then this source could be a new path.
+    iSourceRelativePath = cchSourcePath - cchRelativePath;
+    if (CSTR_EQUAL == ::CompareStringW(LOCALE_NEUTRAL, NORM_IGNORECASE, wzSourcePath + iSourceRelativePath, -1, wzRelativePath, -1))
+    {
+        hr = StrAllocString(&sczSourceFolder, wzSourcePath, iSourceRelativePath);
+        ExitOnFailure(hr, "Failed to trim source folder.");
+
+        hr = VariableGetString(pVariables, BURN_BUNDLE_LAST_USED_SOURCE, &sczLastSourceFolder);
+        if (SUCCEEDED(hr))
+        {
+            nCompare = ::CompareStringW(LOCALE_NEUTRAL, NORM_IGNORECASE, sczSourceFolder, -1, sczLastSourceFolder, -1);
+        }
+        else if (E_NOTFOUND == hr)
+        {
+            nCompare = CSTR_GREATER_THAN;
+            hr = S_OK;
+        }
+
+        if (CSTR_EQUAL != nCompare)
+        {
+            hr = VariableSetLiteralString(pVariables, BURN_BUNDLE_LAST_USED_SOURCE, sczSourceFolder, FALSE);
+            ExitOnFailure(hr, "Failed to set last source.");
+        }
+    }
+
+LExit:
+    ReleaseStr(sczLastSourceFolder);
+    ReleaseStr(sczSourceFolder);
+
+    return hr;
+}
+
+extern "C" HRESULT CacheSendProgressCallback(
+    __in DOWNLOAD_CACHE_CALLBACK* pCallback,
+    __in DWORD64 dw64Progress,
+    __in DWORD64 dw64Total,
+    __in HANDLE hDestinationFile
+    )
+{
+    static LARGE_INTEGER LARGE_INTEGER_ZERO = { };
+
+    HRESULT hr = S_OK;
+    DWORD dwResult = PROGRESS_CONTINUE;
+    LARGE_INTEGER liTotalSize = { };
+    LARGE_INTEGER liTotalTransferred = { };
+
+    if (pCallback->pfnProgress)
+    {
+        liTotalSize.QuadPart = dw64Total;
+        liTotalTransferred.QuadPart = dw64Progress;
+
+        dwResult = (*pCallback->pfnProgress)(liTotalSize, liTotalTransferred, LARGE_INTEGER_ZERO, LARGE_INTEGER_ZERO, 1, CALLBACK_CHUNK_FINISHED, INVALID_HANDLE_VALUE, hDestinationFile, pCallback->pv);
+        switch (dwResult)
+        {
+        case PROGRESS_CONTINUE:
+            hr = S_OK;
+            break;
+
+        case PROGRESS_CANCEL: __fallthrough; // TODO: should cancel and stop be treated differently?
+        case PROGRESS_STOP:
+            hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
+            ExitOnRootFailure(hr, "UX aborted on download progress.");
+
+        case PROGRESS_QUIET: // Not actually an error, just an indication to the caller to stop requesting progress.
+            pCallback->pfnProgress = NULL;
+            hr = S_OK;
+            break;
+
+        default:
+            hr = E_UNEXPECTED;
+            ExitOnRootFailure(hr, "Invalid return code from progress routine.");
+        }
+    }
+
+LExit:
+    return hr;
+}
+
+extern "C" void CacheSendErrorCallback(
+    __in DOWNLOAD_CACHE_CALLBACK* pCallback,
+    __in HRESULT hrError,
+    __in_z_opt LPCWSTR wzError,
+    __out_opt BOOL* pfRetry
+    )
+{
+    if (pfRetry)
+    {
+        *pfRetry = FALSE;
+    }
+
+    if (pCallback->pfnCancel)
+    {
+        int nResult = (*pCallback->pfnCancel)(hrError, wzError, pfRetry != NULL, pCallback->pv);
+        if (pfRetry && IDRETRY == nResult)
+        {
+            *pfRetry = TRUE;
+        }
+    }
+}
+
+extern "C" BOOL CacheBundleRunningFromCache()
+{
+    return vfRunningFromCache;
+}
+
+extern "C" HRESULT CacheBundleToCleanRoom(
+    __in BURN_PAYLOADS* pUxPayloads,
+    __in BURN_SECTION* pSection,
+    __deref_out_z_opt LPWSTR* psczCleanRoomBundlePath
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR sczSourcePath = NULL;
+    LPWSTR wzExecutableName = NULL;
+
+    hr = PathForCurrentProcess(&sczSourcePath, NULL);
+    ExitOnFailure(hr, "Failed to get current path for process to cache to clean room.");
+
+    wzExecutableName = PathFile(sczSourcePath);
+
+    hr = CopyEngineToWorkingFolder(sczSourcePath, BUNDLE_CLEAN_ROOM_WORKING_FOLDER_NAME, wzExecutableName, pUxPayloads, pSection, psczCleanRoomBundlePath);
+    ExitOnFailure(hr, "Failed to cache bundle to clean room.");
+
+LExit:
+    ReleaseStr(sczSourcePath);
+
+    return hr;
+}
+
+extern "C" HRESULT CacheBundleToWorkingDirectory(
+    __in_z LPCWSTR /*wzBundleId*/,
+    __in_z LPCWSTR wzExecutableName,
+    __in BURN_PAYLOADS* pUxPayloads,
+    __in BURN_SECTION* pSection,
+    __deref_out_z_opt LPWSTR* psczEngineWorkingPath
+    )
+{
+    Assert(vfInitializedCache);
+
+    HRESULT hr = S_OK;
+    LPWSTR sczSourcePath = NULL;
+
+    // Initialize the source.
+    hr = PathForCurrentProcess(&sczSourcePath, NULL);
+    ExitOnFailure(hr, "Failed to get current process path.");
+
+    // If the bundle is running out of the package cache then we don't need to copy it to
+    // the working folder since we feel safe in the package cache and will run from there.
+    if (vfRunningFromCache)
+    {
+        hr = StrAllocString(psczEngineWorkingPath, sczSourcePath, 0);
+        ExitOnFailure(hr, "Failed to use current process path as target path.");
+    }
+    else // otherwise, carry on putting the bundle in the working folder.
+    {
+        hr = CopyEngineToWorkingFolder(sczSourcePath, BUNDLE_WORKING_FOLDER_NAME, wzExecutableName, pUxPayloads, pSection, psczEngineWorkingPath);
+        ExitOnFailure(hr, "Failed to copy engine to working folder.");
+    }
+
+LExit:
+    ReleaseStr(sczSourcePath);
+
+    return hr;
+}
+
+extern "C" HRESULT CacheLayoutBundle(
+    __in_z LPCWSTR wzExecutableName,
+    __in_z LPCWSTR wzLayoutDirectory,
+    __in_z LPCWSTR wzSourceBundlePath
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR sczTargetPath = NULL;
+
+    hr = PathConcat(wzLayoutDirectory, wzExecutableName, &sczTargetPath);
+    ExitOnFailure(hr, "Failed to combine completed path with engine file name for layout.");
+
+    LogStringLine(REPORT_STANDARD, "Layout bundle from: '%ls' to: '%ls'", wzSourceBundlePath, sczTargetPath);
+
+    hr = FileEnsureMoveWithRetry(wzSourceBundlePath, sczTargetPath, TRUE, TRUE, FILE_OPERATION_RETRY_COUNT, FILE_OPERATION_RETRY_WAIT);
+    ExitOnFailure(hr, "Failed to layout bundle from: '%ls' to '%ls'", wzSourceBundlePath, sczTargetPath);
+
+LExit:
+    ReleaseStr(sczTargetPath);
+
+    return hr;
+}
+
+extern "C" HRESULT CacheCompleteBundle(
+    __in BOOL fPerMachine,
+    __in_z LPCWSTR wzExecutableName,
+    __in_z LPCWSTR wzBundleId,
+    __in BURN_PAYLOADS* pUxPayloads,
+    __in_z LPCWSTR wzSourceBundlePath
+#ifdef DEBUG
+    , __in_z LPCWSTR wzExecutablePath
+#endif
+    )
+{
+    HRESULT hr = S_OK;
+    int nCompare = 0;
+    LPWSTR sczTargetDirectory = NULL;
+    LPWSTR sczTargetPath = NULL;
+    LPWSTR sczSourceDirectory = NULL;
+    LPWSTR sczPayloadSourcePath = NULL;
+
+    hr = CreateCompletedPath(fPerMachine, wzBundleId, &sczTargetDirectory);
+    ExitOnFailure(hr, "Failed to create completed cache path for bundle.");
+
+    hr = PathConcat(sczTargetDirectory, wzExecutableName, &sczTargetPath);
+    ExitOnFailure(hr, "Failed to combine completed path with engine file name.");
+
+    Assert(CSTR_EQUAL == ::CompareStringW(LOCALE_NEUTRAL, NORM_IGNORECASE, wzExecutablePath, -1, sczTargetPath, -1));
+
+    // If the bundle is running out of the package cache then we don't need to copy it there
+    // (and don't want to since it'll be in use) so bail.
+    hr = PathCompare(wzSourceBundlePath, sczTargetPath, &nCompare);
+    ExitOnFailure(hr, "Failed to compare completed cache path for bundle: %ls", wzSourceBundlePath);
+
+    if (CSTR_EQUAL == nCompare)
+    {
+        ExitFunction();
+    }
+
+    // Otherwise, carry on putting the bundle in the cache.
+    LogStringLine(REPORT_STANDARD, "Caching bundle from: '%ls' to: '%ls'", wzSourceBundlePath, sczTargetPath);
+
+    FileRemoveFromPendingRename(sczTargetPath); // best effort to ensure bundle is not deleted from cache post restart.
+
+    hr = FileEnsureCopyWithRetry(wzSourceBundlePath, sczTargetPath, TRUE, FILE_OPERATION_RETRY_COUNT, FILE_OPERATION_RETRY_WAIT);
+    ExitOnFailure(hr, "Failed to cache bundle from: '%ls' to '%ls'", wzSourceBundlePath, sczTargetPath);
+
+    // Reset the path permissions in the cache.
+    hr = ResetPathPermissions(fPerMachine, sczTargetPath);
+    ExitOnFailure(hr, "Failed to reset permissions on cached bundle: '%ls'", sczTargetPath);
+
+    hr = PathGetDirectory(wzSourceBundlePath, &sczSourceDirectory);
+    ExitOnFailure(hr, "Failed to get directory from engine working path: %ls", wzSourceBundlePath);
+
+    // Cache external UX payloads to completed path.
+    for (DWORD i = 0; i < pUxPayloads->cPayloads; ++i)
+    {
+        BURN_PAYLOAD* pPayload = &pUxPayloads->rgPayloads[i];
+
+        if (BURN_PAYLOAD_PACKAGING_EXTERNAL == pPayload->packaging)
+        {
+            hr = PathConcat(sczSourceDirectory, pPayload->sczSourcePath, &sczPayloadSourcePath);
+            ExitOnFailure(hr, "Failed to build payload source path.");
+
+            hr = CacheCompletePayload(fPerMachine, pPayload, wzBundleId, sczPayloadSourcePath, FALSE);
+            ExitOnFailure(hr, "Failed to complete the cache of payload: %ls", pPayload->sczKey);
+        }
+    }
+
+LExit:
+    ReleaseStr(sczPayloadSourcePath);
+    ReleaseStr(sczSourceDirectory);
+    ReleaseStr(sczTargetPath);
+    ReleaseStr(sczTargetDirectory);
+
+    return hr;
+}
+
+extern "C" HRESULT CacheLayoutContainer(
+    __in BURN_CONTAINER* pContainer,
+    __in_z_opt LPCWSTR wzLayoutDirectory,
+    __in_z LPCWSTR wzUnverifiedContainerPath,
+    __in BOOL fMove
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR sczCachedPath = NULL;
+
+    hr = PathConcat(wzLayoutDirectory, pContainer->sczFilePath, &sczCachedPath);
+    ExitOnFailure(hr, "Failed to concat complete cached path.");
+
+    hr = VerifyThenTransferContainer(pContainer, sczCachedPath, wzUnverifiedContainerPath, fMove);
+    ExitOnFailure(hr, "Failed to layout container from cached path: %ls", sczCachedPath);
+
+LExit:
+    ReleaseStr(sczCachedPath);
+
+    return hr;
+}
+
+extern "C" HRESULT CacheLayoutPayload(
+    __in BURN_PAYLOAD* pPayload,
+    __in_z_opt LPCWSTR wzLayoutDirectory,
+    __in_z LPCWSTR wzUnverifiedPayloadPath,
+    __in BOOL fMove
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR sczCachedPath = NULL;
+
+    hr = PathConcat(wzLayoutDirectory, pPayload->sczFilePath, &sczCachedPath);
+    ExitOnFailure(hr, "Failed to concat complete cached path.");
+
+    hr = VerifyThenTransferPayload(pPayload, sczCachedPath, wzUnverifiedPayloadPath, fMove);
+    ExitOnFailure(hr, "Failed to layout payload from cached payload: %ls", sczCachedPath);
+
+LExit:
+    ReleaseStr(sczCachedPath);
+
+    return hr;
+}
+
+extern "C" HRESULT CacheCompletePayload(
+    __in BOOL fPerMachine,
+    __in BURN_PAYLOAD* pPayload,
+    __in_z_opt LPCWSTR wzCacheId,
+    __in_z LPCWSTR wzWorkingPayloadPath,
+    __in BOOL fMove
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR sczCachedDirectory = NULL;
+    LPWSTR sczCachedPath = NULL;
+    LPWSTR sczUnverifiedPayloadPath = NULL;
+
+    hr = CreateCompletedPath(fPerMachine, wzCacheId, &sczCachedDirectory);
+    ExitOnFailure(hr, "Failed to get cached path for package with cache id: %ls", wzCacheId);
+
+    hr = PathConcat(sczCachedDirectory, pPayload->sczFilePath, &sczCachedPath);
+    ExitOnFailure(hr, "Failed to concat complete cached path.");
+
+    // If the cached file matches what we expected, we're good.
+    hr = VerifyFileAgainstPayload(pPayload, sczCachedPath);
+    if (SUCCEEDED(hr))
+    {
+        ::DecryptFileW(sczCachedPath, 0);  // Let's try to make sure it's not encrypted.
+        LogId(REPORT_STANDARD, MSG_VERIFIED_EXISTING_PAYLOAD, pPayload->sczKey, sczCachedPath);
+        ExitFunction();
+    }
+    else if (E_PATHNOTFOUND != hr && E_FILENOTFOUND != hr)
+    {
+        LogErrorId(hr, MSG_FAILED_VERIFY_PAYLOAD, pPayload->sczKey, sczCachedPath, NULL);
+
+        FileEnsureDelete(sczCachedPath); // if the file existed but did not verify correctly, make it go away.
+    }
+
+    hr = CreateUnverifiedPath(fPerMachine, pPayload->sczKey, &sczUnverifiedPayloadPath);
+    ExitOnFailure(hr, "Failed to create unverified path.");
+
+    // If the working path exists, let's get it into the unverified path so we can reset the ACLs and verify the file.
+    if (FileExistsEx(wzWorkingPayloadPath, NULL))
+    {
+        hr = TransferWorkingPathToUnverifiedPath(wzWorkingPayloadPath, sczUnverifiedPayloadPath, fMove);
+        ExitOnFailure(hr, "Failed to transfer working path to unverified path for payload: %ls.", pPayload->sczKey);
+    }
+    else if (!FileExistsEx(sczUnverifiedPayloadPath, NULL)) // if the working path and unverified path do not exist, nothing we can do.
+    {
+        hr = E_FILENOTFOUND;
+        ExitOnFailure(hr, "Failed to find payload: %ls in working path: %ls and unverified path: %ls", pPayload->sczKey, wzWorkingPayloadPath, sczUnverifiedPayloadPath);
+    }
+
+    hr = ResetPathPermissions(fPerMachine, sczUnverifiedPayloadPath);
+    ExitOnFailure(hr, "Failed to reset permissions on unverified cached payload: %ls", pPayload->sczKey);
+
+    hr = VerifyFileAgainstPayload(pPayload, sczUnverifiedPayloadPath);
+    if (FAILED(hr))
+    {
+        LogErrorId(hr, MSG_FAILED_VERIFY_PAYLOAD, pPayload->sczKey, sczUnverifiedPayloadPath, NULL);
+
+        FileEnsureDelete(sczUnverifiedPayloadPath); // if the file did not verify correctly, make it go away.
+        ExitFunction();
+    }
+
+    LogId(REPORT_STANDARD, MSG_VERIFIED_ACQUIRED_PAYLOAD, pPayload->sczKey, sczUnverifiedPayloadPath, fMove ? "moving" : "copying", sczCachedPath);
+
+    hr = FileEnsureMoveWithRetry(sczUnverifiedPayloadPath, sczCachedPath, TRUE, TRUE, FILE_OPERATION_RETRY_COUNT, FILE_OPERATION_RETRY_WAIT);
+    ExitOnFailure(hr, "Failed to move verified file to complete payload path: %ls", sczCachedPath);
+
+    ::DecryptFileW(sczCachedPath, 0);  // Let's try to make sure it's not encrypted.
+
+LExit:
+    ReleaseStr(sczUnverifiedPayloadPath);
+    ReleaseStr(sczCachedPath);
+    ReleaseStr(sczCachedDirectory);
+
+    return hr;
+}
+
+extern "C" HRESULT CacheRemoveWorkingFolder(
+    __in_z_opt LPCWSTR wzBundleId
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR sczWorkingFolder = NULL;
+
+    if (vfInitializedCache)
+    {
+        hr = CalculateWorkingFolder(wzBundleId, &sczWorkingFolder);
+        ExitOnFailure(hr, "Failed to calculate the working folder to remove it.");
+
+        // Try to clean out everything in the working folder.
+        hr = DirEnsureDeleteEx(sczWorkingFolder, DIR_DELETE_FILES | DIR_DELETE_RECURSE | DIR_DELETE_SCHEDULE);
+        TraceError(hr, "Could not delete bundle engine working folder.");
+    }
+
+LExit:
+    ReleaseStr(sczWorkingFolder);
+
+    return hr;
+}
+
+extern "C" HRESULT CacheRemoveBundle(
+    __in BOOL fPerMachine,
+    __in_z LPCWSTR wzBundleId
+    )
+{
+    HRESULT hr = S_OK;
+
+    hr = RemoveBundleOrPackage(TRUE, fPerMachine, wzBundleId, wzBundleId);
+    ExitOnFailure(hr, "Failed to remove bundle id: %ls.", wzBundleId);
+
+LExit:
+    return hr;
+}
+
+extern "C" HRESULT CacheRemovePackage(
+    __in BOOL fPerMachine,
+    __in_z LPCWSTR wzPackageId,
+    __in_z LPCWSTR wzCacheId
+    )
+{
+    HRESULT hr = S_OK;
+
+    hr = RemoveBundleOrPackage(FALSE, fPerMachine, wzPackageId, wzCacheId);
+    ExitOnFailure(hr, "Failed to remove package id: %ls.", wzPackageId);
+
+LExit:
+    return hr;
+}
+
+extern "C" HRESULT CacheVerifyPayloadSignature(
+    __in BURN_PAYLOAD* pPayload,
+    __in_z LPCWSTR wzUnverifiedPayloadPath,
+    __in HANDLE hFile
+    )
+{
+    HRESULT hr = S_OK;
+    LONG er = ERROR_SUCCESS;
+
+    GUID guidAuthenticode = WINTRUST_ACTION_GENERIC_VERIFY_V2;
+    WINTRUST_FILE_INFO wfi = { };
+    WINTRUST_DATA wtd = { };
+    CRYPT_PROVIDER_DATA* pProviderData = NULL;
+    CRYPT_PROVIDER_SGNR* pSigner = NULL;
+
+    // Verify the payload assuming online.
+    wfi.cbStruct = sizeof(wfi);
+    wfi.pcwszFilePath = wzUnverifiedPayloadPath;
+    wfi.hFile = hFile;
+
+    wtd.cbStruct = sizeof(wtd);
+    wtd.dwUnionChoice = WTD_CHOICE_FILE;
+    wtd.pFile = &wfi;
+    wtd.dwStateAction = WTD_STATEACTION_VERIFY;
+    wtd.dwProvFlags = WTD_REVOCATION_CHECK_CHAIN_EXCLUDE_ROOT;
+    wtd.dwUIChoice = WTD_UI_NONE;
+
+    er = ::WinVerifyTrust(static_cast<HWND>(INVALID_HANDLE_VALUE), &guidAuthenticode, &wtd);
+    if (er)
+    {
+        // Verify the payload assuming offline.
+        wtd.dwProvFlags |= WTD_CACHE_ONLY_URL_RETRIEVAL;
+
+        er = ::WinVerifyTrust(static_cast<HWND>(INVALID_HANDLE_VALUE), &guidAuthenticode, &wtd);
+        ExitOnWin32Error(er, hr, "Failed authenticode verification of payload: %ls", wzUnverifiedPayloadPath);
+    }
+
+    pProviderData = WTHelperProvDataFromStateData(wtd.hWVTStateData);
+    ExitOnNullWithLastError(pProviderData, hr, "Failed to get provider state from authenticode certificate.");
+
+    pSigner = WTHelperGetProvSignerFromChain(pProviderData, 0, FALSE, 0);
+    ExitOnNullWithLastError(pSigner, hr, "Failed to get signer chain from authenticode certificate.");
+
+    hr = VerifyPayloadAgainstChain(pPayload, pSigner->pChainContext);
+    ExitOnFailure(hr, "Failed to verify expected payload against actual certificate chain.");
+
+LExit:
+    return hr;
+}
+
+extern "C" void CacheCleanup(
+    __in BOOL fPerMachine,
+    __in_z LPCWSTR wzBundleId
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR sczFolder = NULL;
+    LPWSTR sczFiles = NULL;
+    LPWSTR sczDelete = NULL;
+    HANDLE hFind = INVALID_HANDLE_VALUE;
+    WIN32_FIND_DATAW wfd = { };
+    DWORD cFileName = 0;
+
+    hr = CacheGetCompletedPath(fPerMachine, UNVERIFIED_CACHE_FOLDER_NAME, &sczFolder);
+    if (SUCCEEDED(hr))
+    {
+        hr = DirEnsureDeleteEx(sczFolder, DIR_DELETE_FILES | DIR_DELETE_RECURSE | DIR_DELETE_SCHEDULE);
+    }
+
+    if (!fPerMachine)
+    {
+        hr = CalculateWorkingFolder(wzBundleId, &sczFolder);
+        if (SUCCEEDED(hr))
+        {
+            hr = PathConcat(sczFolder, L"*.*", &sczFiles);
+            if (SUCCEEDED(hr))
+            {
+                hFind = ::FindFirstFileW(sczFiles, &wfd);
+                if (INVALID_HANDLE_VALUE != hFind)
+                {
+                    do
+                    {
+                        // Skip directories.
+                        if (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
+                        {
+                            continue;
+                        }
+
+                        // For extra safety and to silence OACR.
+                        wfd.cFileName[MAX_PATH - 1] = L'\0';
+
+                        // Skip resume files (they end with ".R").
+                        cFileName = lstrlenW(wfd.cFileName);
+                        if (2 < cFileName && L'.' == wfd.cFileName[cFileName - 2] && (L'R' == wfd.cFileName[cFileName - 1] || L'r' == wfd.cFileName[cFileName - 1]))
+                        {
+                            continue;
+                        }
+
+                        hr = PathConcat(sczFolder, wfd.cFileName, &sczDelete);
+                        if (SUCCEEDED(hr))
+                        {
+                            hr = FileEnsureDelete(sczDelete);
+                        }
+                    } while (::FindNextFileW(hFind, &wfd));
+                }
+            }
+        }
+    }
+
+    if (INVALID_HANDLE_VALUE != hFind)
+    {
+        ::FindClose(hFind);
+    }
+
+    ReleaseStr(sczDelete);
+    ReleaseStr(sczFiles);
+    ReleaseStr(sczFolder);
+}
+
+extern "C" void CacheUninitialize()
+{
+    ReleaseNullStr(vsczCurrentMachinePackageCache);
+    ReleaseNullStr(vsczDefaultMachinePackageCache);
+    ReleaseNullStr(vsczDefaultUserPackageCache);
+    ReleaseNullStr(vsczWorkingFolder);
+    ReleaseNullStr(vsczSourceProcessPath);
+
+    vfRunningFromCache = FALSE;
+    vfInitializedCache = FALSE;
+}
+
+// Internal functions.
+
+static HRESULT CalculateWorkingFolder(
+    __in_z LPCWSTR /*wzBundleId*/,
+    __deref_out_z LPWSTR* psczWorkingFolder
+    )
+{
+    HRESULT hr = S_OK;
+    RPC_STATUS rs = RPC_S_OK;
+    BOOL fElevated = FALSE;
+    WCHAR wzTempPath[MAX_PATH] = { };
+    UUID guid = {};
+    WCHAR wzGuid[39];
+
+    if (!vsczWorkingFolder)
+    {
+        ProcElevated(::GetCurrentProcess(), &fElevated);
+
+        if (fElevated)
+        {
+            if (!::GetWindowsDirectoryW(wzTempPath, countof(wzTempPath)))
+            {
+                ExitWithLastError(hr, "Failed to get windows path for working folder.");
+            }
+
+            hr = PathFixedBackslashTerminate(wzTempPath, countof(wzTempPath));
+            ExitOnFailure(hr, "Failed to ensure windows path for working folder ended in backslash.");
+
+            hr = ::StringCchCatW(wzTempPath, countof(wzTempPath), L"Temp\\");
+            ExitOnFailure(hr, "Failed to concat Temp directory on windows path for working folder.");
+        }
+        else if (0 == ::GetTempPathW(countof(wzTempPath), wzTempPath))
+        {
+            ExitWithLastError(hr, "Failed to get temp path for working folder.");
+        }
+
+        rs = ::UuidCreate(&guid);
+        hr = HRESULT_FROM_RPC(rs);
+        ExitOnFailure(hr, "Failed to create working folder guid.");
+
+        if (!::StringFromGUID2(guid, wzGuid, countof(wzGuid)))
+        {
+            hr = E_OUTOFMEMORY;
+            ExitOnRootFailure(hr, "Failed to convert working folder guid into string.");
+        }
+
+        hr = StrAllocFormatted(&vsczWorkingFolder, L"%ls%ls\\", wzTempPath, wzGuid);
+        ExitOnFailure(hr, "Failed to append bundle id on to temp path for working folder.");
+    }
+
+    hr = StrAllocString(psczWorkingFolder, vsczWorkingFolder, 0);
+    ExitOnFailure(hr, "Failed to copy working folder path.");
+
+LExit:
+    return hr;
+}
+
+static HRESULT GetRootPath(
+    __in BOOL fPerMachine,
+    __in BOOL fAllowRedirect,
+    __deref_out_z LPWSTR* psczRootPath
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR sczAppData = NULL;
+    int nCompare = 0;
+
+    // Cache paths are initialized once so they cannot be changed while the engine is caching payloads.
+    if (fPerMachine)
+    {
+        // Always construct the default machine package cache path so we can determine if we're redirected.
+        if (!vsczDefaultMachinePackageCache)
+        {
+            hr = PathGetKnownFolder(CSIDL_COMMON_APPDATA, &sczAppData);
+            ExitOnFailure(hr, "Failed to find local %hs appdata directory.", "per-machine");
+
+            hr = PathConcat(sczAppData, PACKAGE_CACHE_FOLDER_NAME, &vsczDefaultMachinePackageCache);
+            ExitOnFailure(hr, "Failed to construct %hs package cache directory name.", "per-machine");
+
+            hr = PathBackslashTerminate(&vsczDefaultMachinePackageCache);
+            ExitOnFailure(hr, "Failed to backslash terminate default %hs package cache directory name.", "per-machine");
+        }
+
+        if (!vsczCurrentMachinePackageCache)
+        {
+            hr = PolcReadString(POLICY_BURN_REGISTRY_PATH, L"PackageCache", NULL, &vsczCurrentMachinePackageCache);
+            ExitOnFailure(hr, "Failed to read PackageCache policy directory.");
+
+            if (vsczCurrentMachinePackageCache)
+            {
+                hr = PathBackslashTerminate(&vsczCurrentMachinePackageCache);
+                ExitOnFailure(hr, "Failed to backslash terminate redirected per-machine package cache directory name.");
+            }
+            else
+            {
+                hr = StrAllocString(&vsczCurrentMachinePackageCache, vsczDefaultMachinePackageCache, 0);
+                ExitOnFailure(hr, "Failed to copy default package cache directory to current package cache directory.");
+            }
+        }
+
+        hr = StrAllocString(psczRootPath, fAllowRedirect ? vsczCurrentMachinePackageCache : vsczDefaultMachinePackageCache, 0);
+        ExitOnFailure(hr, "Failed to copy %hs package cache root directory.", "per-machine");
+
+        hr = PathCompare(vsczDefaultMachinePackageCache, *psczRootPath, &nCompare);
+        ExitOnFailure(hr, "Failed to compare default and current package cache directories.");
+
+        // Return S_FALSE if the current location is not the default location (redirected).
+        hr = CSTR_EQUAL == nCompare ? S_OK : S_FALSE;
+    }
+    else
+    {
+        if (!vsczDefaultUserPackageCache)
+        {
+            hr = PathGetKnownFolder(CSIDL_LOCAL_APPDATA, &sczAppData);
+            ExitOnFailure(hr, "Failed to find local %hs appdata directory.", "per-user");
+
+            hr = PathConcat(sczAppData, PACKAGE_CACHE_FOLDER_NAME, &vsczDefaultUserPackageCache);
+            ExitOnFailure(hr, "Failed to construct %hs package cache directory name.", "per-user");
+
+            hr = PathBackslashTerminate(&vsczDefaultUserPackageCache);
+            ExitOnFailure(hr, "Failed to backslash terminate default %hs package cache directory name.", "per-user");
+        }
+
+        hr = StrAllocString(psczRootPath, vsczDefaultUserPackageCache, 0);
+        ExitOnFailure(hr, "Failed to copy %hs package cache root directory.", "per-user");
+    }
+
+LExit:
+    ReleaseStr(sczAppData);
+
+    return hr;
+}
+
+static HRESULT GetLastUsedSourceFolder(
+    __in BURN_VARIABLES* pVariables,
+    __out_z LPWSTR* psczLastSource
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR sczOriginalSource = NULL;
+
+    hr = VariableGetString(pVariables, BURN_BUNDLE_LAST_USED_SOURCE, psczLastSource);
+    if (E_NOTFOUND == hr)
+    {
+        // Try the original source folder.
+        hr = VariableGetString(pVariables, BURN_BUNDLE_ORIGINAL_SOURCE, &sczOriginalSource);
+        if (SUCCEEDED(hr))
+        {
+            hr = PathGetDirectory(sczOriginalSource, psczLastSource);
+        }
+    }
+
+    return hr;
+}
+
+static HRESULT CreateCompletedPath(
+    __in BOOL fPerMachine,
+    __in LPCWSTR wzId,
+    __out LPWSTR* psczCacheDirectory
+    )
+{
+    static BOOL fPerMachineCacheRootVerified = FALSE;
+
+    HRESULT hr = S_OK;
+    LPWSTR sczCacheDirectory = NULL;
+
+    // If we are doing a permachine install but have not yet verified that the root cache folder
+    // was created with the correct ACLs yet, do that now.
+    if (fPerMachine && !fPerMachineCacheRootVerified)
+    {
+        hr = GetRootPath(fPerMachine, TRUE, &sczCacheDirectory);
+        ExitOnFailure(hr, "Failed to get cache directory.");
+
+        hr = DirEnsureExists(sczCacheDirectory, NULL);
+        ExitOnFailure(hr, "Failed to create cache directory: %ls", sczCacheDirectory);
+
+        hr = SecurePath(sczCacheDirectory);
+        ExitOnFailure(hr, "Failed to secure cache directory: %ls", sczCacheDirectory);
+
+        fPerMachineCacheRootVerified = TRUE;
+    }
+
+    // Get the cache completed path, ensure it exists, and reset any permissions people
+    // might have tried to set on the directory so we inherit the (correct!) security
+    // permissions from the parent directory.
+    hr = CacheGetCompletedPath(fPerMachine, wzId, &sczCacheDirectory);
+    ExitOnFailure(hr, "Failed to get cache directory.");
+
+    hr = DirEnsureExists(sczCacheDirectory, NULL);
+    ExitOnFailure(hr, "Failed to create cache directory: %ls", sczCacheDirectory);
+
+    ResetPathPermissions(fPerMachine, sczCacheDirectory);
+
+    *psczCacheDirectory = sczCacheDirectory;
+    sczCacheDirectory = NULL;
+
+LExit:
+    ReleaseStr(sczCacheDirectory);
+    return hr;
+}
+
+static HRESULT CreateUnverifiedPath(
+    __in BOOL fPerMachine,
+    __in_z LPCWSTR wzPayloadId,
+    __out_z LPWSTR* psczUnverifiedPayloadPath
+    )
+{
+    static BOOL fUnverifiedCacheFolderCreated = FALSE;
+
+    HRESULT hr = S_OK;
+    LPWSTR sczUnverifiedCacheFolder = NULL;
+
+    hr = CacheGetCompletedPath(fPerMachine, UNVERIFIED_CACHE_FOLDER_NAME, &sczUnverifiedCacheFolder);
+    ExitOnFailure(hr, "Failed to get cache directory.");
+
+    if (!fUnverifiedCacheFolderCreated)
+    {
+        hr = DirEnsureExists(sczUnverifiedCacheFolder, NULL);
+        ExitOnFailure(hr, "Failed to create unverified cache directory: %ls", sczUnverifiedCacheFolder);
+
+        ResetPathPermissions(fPerMachine, sczUnverifiedCacheFolder);
+    }
+
+    hr = PathConcat(sczUnverifiedCacheFolder, wzPayloadId, psczUnverifiedPayloadPath);
+    ExitOnFailure(hr, "Failed to concat payload id to unverified folder path.");
+
+LExit:
+    ReleaseStr(sczUnverifiedCacheFolder);
+
+    return hr;
+}
+
+static HRESULT VerifyThenTransferContainer(
+    __in BURN_CONTAINER* pContainer,
+    __in_z LPCWSTR wzCachedPath,
+    __in_z LPCWSTR wzUnverifiedContainerPath,
+    __in BOOL fMove
+    )
+{
+    HRESULT hr = S_OK;
+    HANDLE hFile = INVALID_HANDLE_VALUE;
+
+    // Get the container on disk actual hash.
+    hFile = ::CreateFileW(wzUnverifiedContainerPath, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_DELETE, NULL, OPEN_EXISTING, FILE_FLAG_SEQUENTIAL_SCAN, NULL);
+    if (INVALID_HANDLE_VALUE == hFile)
+    {
+        ExitWithLastError(hr, "Failed to open container in working path: %ls", wzUnverifiedContainerPath);
+    }
+
+    // Container should have a hash we can use to verify with.
+    if (pContainer->pbHash)
+    {
+        hr = VerifyHash(pContainer->pbHash, pContainer->cbHash, wzUnverifiedContainerPath, hFile);
+        ExitOnFailure(hr, "Failed to verify container hash: %ls", wzCachedPath);
+    }
+
+    LogStringLine(REPORT_STANDARD, "%ls container from working path '%ls' to path '%ls'", fMove ? L"Moving" : L"Copying", wzUnverifiedContainerPath, wzCachedPath);
+
+    if (fMove)
+    {
+        hr = FileEnsureMoveWithRetry(wzUnverifiedContainerPath, wzCachedPath, TRUE, TRUE, FILE_OPERATION_RETRY_COUNT, FILE_OPERATION_RETRY_WAIT);
+        ExitOnFailure(hr, "Failed to move %ls to %ls", wzUnverifiedContainerPath, wzCachedPath);
+    }
+    else
+    {
+        hr = FileEnsureCopyWithRetry(wzUnverifiedContainerPath, wzCachedPath, TRUE, FILE_OPERATION_RETRY_COUNT, FILE_OPERATION_RETRY_WAIT);
+        ExitOnFailure(hr, "Failed to copy %ls to %ls", wzUnverifiedContainerPath, wzCachedPath);
+    }
+
+LExit:
+    ReleaseFileHandle(hFile);
+
+    return hr;
+}
+
+static HRESULT VerifyThenTransferPayload(
+    __in BURN_PAYLOAD* pPayload,
+    __in_z LPCWSTR wzCachedPath,
+    __in_z LPCWSTR wzUnverifiedPayloadPath,
+    __in BOOL fMove
+    )
+{
+    HRESULT hr = S_OK;
+    HANDLE hFile = INVALID_HANDLE_VALUE;
+
+    // Get the payload on disk actual hash.
+    hFile = ::CreateFileW(wzUnverifiedPayloadPath, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_DELETE, NULL, OPEN_EXISTING, FILE_FLAG_SEQUENTIAL_SCAN, NULL);
+    if (INVALID_HANDLE_VALUE == hFile)
+    {
+        ExitWithLastError(hr, "Failed to open payload in working path: %ls", wzUnverifiedPayloadPath);
+    }
+
+    // If the payload has a certificate root public key identifier provided, verify the certificate.
+    if (pPayload->pbCertificateRootPublicKeyIdentifier)
+    {
+        hr = CacheVerifyPayloadSignature(pPayload, wzUnverifiedPayloadPath, hFile);
+        ExitOnFailure(hr, "Failed to verify payload signature: %ls", wzCachedPath);
+    }
+    else if (pPayload->pCatalog) // If catalog files are specified, attempt to verify the file with a catalog file
+    {
+        hr = VerifyPayloadWithCatalog(pPayload, wzUnverifiedPayloadPath, hFile);
+        ExitOnFailure(hr, "Failed to verify payload signature: %ls", wzCachedPath);
+    }
+    else if (pPayload->pbHash) // the payload should have a hash we can use to verify it.
+    {
+        hr = VerifyHash(pPayload->pbHash, pPayload->cbHash, wzUnverifiedPayloadPath, hFile);
+        ExitOnFailure(hr, "Failed to verify payload hash: %ls", wzCachedPath);
+    }
+
+    LogStringLine(REPORT_STANDARD, "%ls payload from working path '%ls' to path '%ls'", fMove ? L"Moving" : L"Copying", wzUnverifiedPayloadPath, wzCachedPath);
+
+    if (fMove)
+    {
+        hr = FileEnsureMoveWithRetry(wzUnverifiedPayloadPath, wzCachedPath, TRUE, TRUE, FILE_OPERATION_RETRY_COUNT, FILE_OPERATION_RETRY_WAIT);
+        ExitOnFailure(hr, "Failed to move %ls to %ls", wzUnverifiedPayloadPath, wzCachedPath);
+    }
+    else
+    {
+        hr = FileEnsureCopyWithRetry(wzUnverifiedPayloadPath, wzCachedPath, TRUE, FILE_OPERATION_RETRY_COUNT, FILE_OPERATION_RETRY_WAIT);
+        ExitOnFailure(hr, "Failed to copy %ls to %ls", wzUnverifiedPayloadPath, wzCachedPath);
+    }
+
+LExit:
+    ReleaseFileHandle(hFile);
+
+    return hr;
+}
+
+static HRESULT TransferWorkingPathToUnverifiedPath(
+    __in_z LPCWSTR wzWorkingPath,
+    __in_z LPCWSTR wzUnverifiedPayloadPath,
+    __in BOOL fMove
+    )
+{
+    HRESULT hr = S_OK;
+
+    if (fMove)
+    {
+        hr = FileEnsureMoveWithRetry(wzWorkingPath, wzUnverifiedPayloadPath, TRUE, TRUE, FILE_OPERATION_RETRY_COUNT, FILE_OPERATION_RETRY_WAIT);
+        ExitOnFailure(hr, "Failed to move %ls to %ls", wzWorkingPath, wzUnverifiedPayloadPath);
+    }
+    else
+    {
+        hr = FileEnsureCopyWithRetry(wzWorkingPath, wzUnverifiedPayloadPath, TRUE, FILE_OPERATION_RETRY_COUNT, FILE_OPERATION_RETRY_WAIT);
+        ExitOnFailure(hr, "Failed to copy %ls to %ls", wzWorkingPath, wzUnverifiedPayloadPath);
+    }
+
+LExit:
+    return hr;
+}
+
+static HRESULT VerifyFileAgainstPayload(
+    __in BURN_PAYLOAD* pPayload,
+    __in_z LPCWSTR wzVerifyPath
+    )
+{
+    HRESULT hr = S_OK;
+    HANDLE hFile = INVALID_HANDLE_VALUE;
+
+    // Get the payload on disk actual hash.
+    hFile = ::CreateFileW(wzVerifyPath, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_DELETE, NULL, OPEN_EXISTING, FILE_FLAG_SEQUENTIAL_SCAN, NULL);
+    if (INVALID_HANDLE_VALUE == hFile)
+    {
+        hr = HRESULT_FROM_WIN32(::GetLastError());
+        if (E_PATHNOTFOUND == hr || E_FILENOTFOUND == hr)
+        {
+            ExitFunction(); // do not log error when the file was not found.
+        }
+        ExitOnRootFailure(hr, "Failed to open payload at path: %ls", wzVerifyPath);
+    }
+
+    // If the payload has a certificate root public key identifier provided, verify the certificate.
+    if (pPayload->pbCertificateRootPublicKeyIdentifier)
+    {
+        hr = CacheVerifyPayloadSignature(pPayload, wzVerifyPath, hFile);
+        ExitOnFailure(hr, "Failed to verify signature of payload: %ls", pPayload->sczKey);
+    }
+    else if (pPayload->pCatalog) // If catalog files are specified, attempt to verify the file with a catalog file
+    {
+        hr = VerifyPayloadWithCatalog(pPayload, wzVerifyPath, hFile);
+        ExitOnFailure(hr, "Failed to verify catalog signature of payload: %ls", pPayload->sczKey);
+    }
+    else if (pPayload->pbHash) // the payload should have a hash we can use to verify it.
+    {
+        hr = VerifyHash(pPayload->pbHash, pPayload->cbHash, wzVerifyPath, hFile);
+        ExitOnFailure(hr, "Failed to verify hash of payload: %ls", pPayload->sczKey);
+    }
+
+LExit:
+    ReleaseFileHandle(hFile);
+
+    return hr;
+}
+
+static HRESULT AllocateSid(
+    __in WELL_KNOWN_SID_TYPE type,
+    __out PSID* ppSid
+    )
+{
+    HRESULT hr = S_OK;
+    PSID pAllocSid = NULL;
+    DWORD cbSid = SECURITY_MAX_SID_SIZE;
+
+    pAllocSid = static_cast<PSID>(MemAlloc(cbSid, TRUE));
+    ExitOnNull(pAllocSid, hr, E_OUTOFMEMORY, "Failed to allocate memory for well known SID.");
+
+    if (!::CreateWellKnownSid(type, NULL, pAllocSid, &cbSid))
+    {
+        ExitWithLastError(hr, "Failed to create well known SID.");
+    }
+
+    *ppSid = pAllocSid;
+    pAllocSid = NULL;
+
+LExit:
+    ReleaseMem(pAllocSid);
+    return hr;
+}
+
+
+static HRESULT ResetPathPermissions(
+    __in BOOL fPerMachine,
+    __in LPCWSTR wzPath
+    )
+{
+    HRESULT hr = S_OK;
+    DWORD er = ERROR_SUCCESS;
+    DWORD dwSetSecurity = DACL_SECURITY_INFORMATION | UNPROTECTED_DACL_SECURITY_INFORMATION;
+    ACL acl = { };
+    PSID pSid = NULL;
+
+    if (fPerMachine)
+    {
+        hr = AllocateSid(WinBuiltinAdministratorsSid, &pSid);
+        ExitOnFailure(hr, "Failed to allocate administrator SID.");
+
+        // Create an empty (not NULL!) ACL to reset the permissions on the file to purely inherit from parent.
+        if (!::InitializeAcl(&acl, sizeof(acl), ACL_REVISION))
+        {
+            ExitWithLastError(hr, "Failed to initialize ACL.");
+        }
+
+        dwSetSecurity |= OWNER_SECURITY_INFORMATION;
+    }
+
+    hr = AclSetSecurityWithRetry(wzPath, SE_FILE_OBJECT, dwSetSecurity, pSid, NULL, &acl, NULL, FILE_OPERATION_RETRY_COUNT, FILE_OPERATION_RETRY_WAIT);
+    ExitOnWin32Error(er, hr, "Failed to reset the ACL on cached file: %ls", wzPath);
+
+    ::SetFileAttributesW(wzPath, FILE_ATTRIBUTE_NORMAL); // Let's try to reset any possible read-only/system bits.
+
+LExit:
+    ReleaseMem(pSid);
+    return hr;
+}
+
+
+static HRESULT GrantAccessAndAllocateSid(
+    __in WELL_KNOWN_SID_TYPE type,
+    __in DWORD dwGrantAccess,
+    __in EXPLICIT_ACCESS* pAccess
+    )
+{
+    HRESULT hr = S_OK;
+
+    hr = AllocateSid(type, reinterpret_cast<PSID*>(&pAccess->Trustee.ptstrName));
+    ExitOnFailure(hr, "Failed to allocate SID to grate access.");
+
+    pAccess->grfAccessMode = GRANT_ACCESS;
+    pAccess->grfAccessPermissions = dwGrantAccess;
+    pAccess->grfInheritance = SUB_CONTAINERS_AND_OBJECTS_INHERIT;
+    pAccess->Trustee.TrusteeForm = TRUSTEE_IS_SID;
+    pAccess->Trustee.TrusteeType = TRUSTEE_IS_GROUP;
+
+LExit:
+    return hr;
+}
+
+
+static HRESULT SecurePath(
+    __in LPCWSTR wzPath
+    )
+{
+    HRESULT hr = S_OK;
+    DWORD er = ERROR_SUCCESS;
+    EXPLICIT_ACCESSW access[4] = { };
+    PACL pAcl = NULL;
+
+    // Administrators must be the first one in the array so we can reuse the allocated SID below.
+    hr = GrantAccessAndAllocateSid(WinBuiltinAdministratorsSid, FILE_ALL_ACCESS, &access[0]);
+    ExitOnFailure(hr, "Failed to allocate access for Administrators group to path: %ls", wzPath);
+
+    hr = GrantAccessAndAllocateSid(WinLocalSystemSid, FILE_ALL_ACCESS, &access[1]);
+    ExitOnFailure(hr, "Failed to allocate access for SYSTEM group to path: %ls", wzPath);
+
+    hr = GrantAccessAndAllocateSid(WinWorldSid, GENERIC_READ | GENERIC_EXECUTE, &access[2]);
+    ExitOnFailure(hr, "Failed to allocate access for Everyone group to path: %ls", wzPath);
+
+    hr = GrantAccessAndAllocateSid(WinBuiltinUsersSid, GENERIC_READ | GENERIC_EXECUTE, &access[3]);
+    ExitOnFailure(hr, "Failed to allocate access for Users group to path: %ls", wzPath);
+
+    er = ::SetEntriesInAclW(countof(access), access, NULL, &pAcl);
+    ExitOnWin32Error(er, hr, "Failed to create ACL to secure cache path: %ls", wzPath);
+
+    // Set the ACL and ensure the Administrators group ends up the owner
+    hr = AclSetSecurityWithRetry(wzPath, SE_FILE_OBJECT, OWNER_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION | PROTECTED_DACL_SECURITY_INFORMATION,
+                                 reinterpret_cast<PSID>(access[0].Trustee.ptstrName), NULL, pAcl, NULL, FILE_OPERATION_RETRY_COUNT, FILE_OPERATION_RETRY_WAIT);
+    ExitOnFailure(hr, "Failed to secure cache path: %ls", wzPath);
+
+LExit:
+    if (pAcl)
+    {
+        ::LocalFree(pAcl);
+    }
+
+    for (DWORD i = 0; i < countof(access); ++i)
+    {
+        ReleaseMem(access[i].Trustee.ptstrName);
+    }
+
+    return hr;
+}
+
+
+static HRESULT CopyEngineToWorkingFolder(
+    __in_z LPCWSTR wzSourcePath,
+    __in_z LPCWSTR wzWorkingFolderName,
+    __in_z LPCWSTR wzExecutableName,
+    __in BURN_PAYLOADS* pUxPayloads,
+    __in BURN_SECTION* pSection,
+    __deref_out_z_opt LPWSTR* psczEngineWorkingPath
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR sczWorkingFolder = NULL;
+    LPWSTR sczTargetDirectory = NULL;
+    LPWSTR sczTargetPath = NULL;
+    LPWSTR sczSourceDirectory = NULL;
+    LPWSTR sczPayloadSourcePath = NULL;
+    LPWSTR sczPayloadTargetPath = NULL;
+
+    hr = CacheEnsureWorkingFolder(NULL, &sczWorkingFolder);
+    ExitOnFailure(hr, "Failed to create working path to copy engine.");
+
+    hr = PathConcat(sczWorkingFolder, wzWorkingFolderName, &sczTargetDirectory);
+    ExitOnFailure(hr, "Failed to calculate the bundle working folder target name.");
+
+    hr = DirEnsureExists(sczTargetDirectory, NULL);
+    ExitOnFailure(hr, "Failed create bundle working folder.");
+
+    hr = PathConcat(sczTargetDirectory, wzExecutableName, &sczTargetPath);
+    ExitOnFailure(hr, "Failed to combine working path with engine file name.");
+
+    // Copy the engine without any attached containers to the working path.
+    hr = CopyEngineWithSignatureFixup(pSection->hEngineFile, wzSourcePath, sczTargetPath, pSection);
+    ExitOnFailure(hr, "Failed to copy engine: '%ls' to working path: %ls", wzSourcePath, sczTargetPath);
+
+    // Copy external UX payloads to working path.
+    for (DWORD i = 0; i < pUxPayloads->cPayloads; ++i)
+    {
+        BURN_PAYLOAD* pPayload = &pUxPayloads->rgPayloads[i];
+
+        if (BURN_PAYLOAD_PACKAGING_EXTERNAL == pPayload->packaging)
+        {
+            if (!sczSourceDirectory)
+            {
+                hr = PathGetDirectory(wzSourcePath, &sczSourceDirectory);
+                ExitOnFailure(hr, "Failed to get directory from engine path: %ls", wzSourcePath);
+            }
+
+            hr = PathConcat(sczSourceDirectory, pPayload->sczSourcePath, &sczPayloadSourcePath);
+            ExitOnFailure(hr, "Failed to build payload source path for working copy.");
+
+            hr = PathConcat(sczTargetDirectory, pPayload->sczFilePath, &sczPayloadTargetPath);
+            ExitOnFailure(hr, "Failed to build payload target path for working copy.");
+
+            hr = FileEnsureCopyWithRetry(sczPayloadSourcePath, sczPayloadTargetPath, TRUE, FILE_OPERATION_RETRY_COUNT, FILE_OPERATION_RETRY_WAIT);
+            ExitOnFailure(hr, "Failed to copy UX payload from: '%ls' to: '%ls'", sczPayloadSourcePath, sczPayloadTargetPath);
+        }
+    }
+
+    if (psczEngineWorkingPath)
+    {
+        hr = StrAllocString(psczEngineWorkingPath, sczTargetPath, 0);
+        ExitOnFailure(hr, "Failed to copy target path for engine working path.");
+    }
+
+LExit:
+    ReleaseStr(sczPayloadTargetPath);
+    ReleaseStr(sczPayloadSourcePath);
+    ReleaseStr(sczSourceDirectory);
+    ReleaseStr(sczTargetPath);
+    ReleaseStr(sczTargetDirectory);
+    ReleaseStr(sczWorkingFolder);
+
+    return hr;
+}
+
+
+static HRESULT CopyEngineWithSignatureFixup(
+    __in HANDLE hEngineFile,
+    __in_z LPCWSTR wzEnginePath,
+    __in_z LPCWSTR wzTargetPath,
+    __in BURN_SECTION* pSection
+    )
+{
+    HRESULT hr = S_OK;
+    HANDLE hTarget = INVALID_HANDLE_VALUE;
+    LARGE_INTEGER li = { };
+    DWORD dwZeroOriginals[3] = { };
+
+    hTarget = ::CreateFileW(wzTargetPath, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_DELETE, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN, NULL);
+    if (INVALID_HANDLE_VALUE == hTarget)
+    {
+        ExitWithLastError(hr, "Failed to create engine file at path: %ls", wzTargetPath);
+    }
+
+    hr = FileSetPointer(hEngineFile, 0, NULL, FILE_BEGIN);
+    ExitOnFailure(hr, "Failed to seek to beginning of engine file: %ls", wzEnginePath);
+
+    hr = FileCopyUsingHandles(hEngineFile, hTarget, pSection->cbEngineSize, NULL);
+    ExitOnFailure(hr, "Failed to copy engine from: %ls to: %ls", wzEnginePath, wzTargetPath);
+
+    // If the original executable was signed, let's put back the checksum and signature.
+    if (pSection->dwOriginalSignatureOffset)
+    {
+        // Fix up the checksum.
+        li.QuadPart = pSection->dwChecksumOffset;
+        if (!::SetFilePointerEx(hTarget, li, NULL, FILE_BEGIN))
+        {
+            ExitWithLastError(hr, "Failed to seek to checksum in exe header.");
+        }
+
+        hr = FileWriteHandle(hTarget, reinterpret_cast<LPBYTE>(&pSection->dwOriginalChecksum), sizeof(pSection->dwOriginalChecksum));
+        ExitOnFailure(hr, "Failed to update signature offset.");
+
+        // Fix up the signature information.
+        li.QuadPart = pSection->dwCertificateTableOffset;
+        if (!::SetFilePointerEx(hTarget, li, NULL, FILE_BEGIN))
+        {
+            ExitWithLastError(hr, "Failed to seek to signature table in exe header.");
+        }
+
+        hr = FileWriteHandle(hTarget, reinterpret_cast<LPBYTE>(&pSection->dwOriginalSignatureOffset), sizeof(pSection->dwOriginalSignatureOffset));
+        ExitOnFailure(hr, "Failed to update signature offset.");
+
+        hr = FileWriteHandle(hTarget, reinterpret_cast<LPBYTE>(&pSection->dwOriginalSignatureSize), sizeof(pSection->dwOriginalSignatureSize));
+        ExitOnFailure(hr, "Failed to update signature offset.");
+
+        // Zero out the original information since that is how it was when the file was originally signed.
+        li.QuadPart = pSection->dwOriginalChecksumAndSignatureOffset;
+        if (!::SetFilePointerEx(hTarget, li, NULL, FILE_BEGIN))
+        {
+            ExitWithLastError(hr, "Failed to seek to original data in exe burn section header.");
+        }
+
+        hr = FileWriteHandle(hTarget, reinterpret_cast<LPBYTE>(&dwZeroOriginals), sizeof(dwZeroOriginals));
+        ExitOnFailure(hr, "Failed to zero out original data offset.");
+    }
+
+LExit:
+    ReleaseFileHandle(hTarget);
+
+    return hr;
+}
+
+
+static HRESULT RemoveBundleOrPackage(
+    __in BOOL fBundle,
+    __in BOOL fPerMachine,
+    __in_z LPCWSTR wzBundleOrPackageId,
+    __in_z LPCWSTR wzCacheId
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR sczRootCacheDirectory = NULL;
+    LPWSTR sczDirectory = NULL;
+
+    hr = CacheGetCompletedPath(fPerMachine, wzCacheId, &sczDirectory);
+    ExitOnFailure(hr, "Failed to calculate cache path.");
+
+    LogId(REPORT_STANDARD, fBundle ? MSG_UNCACHE_BUNDLE : MSG_UNCACHE_PACKAGE, wzBundleOrPackageId, sczDirectory);
+
+    // Try really hard to remove the cache directory.
+    hr = E_FAIL;
+    for (DWORD iRetry = 0; FAILED(hr) && iRetry < FILE_OPERATION_RETRY_COUNT; ++iRetry)
+    {
+        if (0 < iRetry)
+        {
+            ::Sleep(FILE_OPERATION_RETRY_WAIT);
+        }
+
+        hr = DirEnsureDeleteEx(sczDirectory, DIR_DELETE_FILES | DIR_DELETE_RECURSE | DIR_DELETE_SCHEDULE);
+        if (E_PATHNOTFOUND == hr)
+        {
+            break;
+        }
+    }
+
+    if (FAILED(hr))
+    {
+        LogId(REPORT_STANDARD, fBundle ? MSG_UNABLE_UNCACHE_BUNDLE : MSG_UNABLE_UNCACHE_PACKAGE, wzBundleOrPackageId, sczDirectory, hr);
+        hr = S_OK;
+    }
+    else
+    {
+        // Try to remove root package cache in the off chance it is now empty.
+        hr = GetRootPath(fPerMachine, TRUE, &sczRootCacheDirectory);
+        ExitOnFailure(hr, "Failed to get %hs package cache root directory.", fPerMachine ? "per-machine" : "per-user");
+        DirEnsureDeleteEx(sczRootCacheDirectory, DIR_DELETE_SCHEDULE);
+
+        // GetRootPath returns S_FALSE if the package cache is redirected elsewhere.
+        if (S_FALSE == hr)
+        {
+            hr = GetRootPath(fPerMachine, FALSE, &sczRootCacheDirectory);
+            ExitOnFailure(hr, "Failed to get old %hs package cache root directory.", fPerMachine ? "per-machine" : "per-user");
+            DirEnsureDeleteEx(sczRootCacheDirectory, DIR_DELETE_SCHEDULE);
+        }
+    }
+
+LExit:
+    ReleaseStr(sczDirectory);
+    ReleaseStr(sczRootCacheDirectory);
+
+    return hr;
+}
+
+static HRESULT VerifyHash(
+    __in BYTE* pbHash,
+    __in DWORD cbHash,
+    __in_z LPCWSTR wzUnverifiedPayloadPath,
+    __in HANDLE hFile
+    )
+{
+    UNREFERENCED_PARAMETER(wzUnverifiedPayloadPath);
+
+    HRESULT hr = S_OK;
+    BYTE rgbActualHash[SHA1_HASH_LEN] = { };
+    DWORD64 qwHashedBytes;
+    LPWSTR pszExpected = NULL;
+    LPWSTR pszActual = NULL;
+
+    // TODO: create a cryp hash file that sends progress.
+    hr = CrypHashFileHandle(hFile, PROV_RSA_FULL, CALG_SHA1, rgbActualHash, sizeof(rgbActualHash), &qwHashedBytes);
+    ExitOnFailure(hr, "Failed to calculate hash for path: %ls", wzUnverifiedPayloadPath);
+
+    // Compare hashes.
+    if (cbHash != sizeof(rgbActualHash) || 0 != memcmp(pbHash, rgbActualHash, SHA1_HASH_LEN))
+    {
+        hr = CRYPT_E_HASH_VALUE;
+
+        // Best effort to log the expected and actual hash value strings.
+        if (SUCCEEDED(StrAllocHexEncode(pbHash, cbHash, &pszExpected)) &&
+            SUCCEEDED(StrAllocHexEncode(rgbActualHash, SHA1_HASH_LEN, &pszActual)))
+        {
+            ExitOnFailure(hr, "Hash mismatch for path: %ls, expected: %ls, actual: %ls", wzUnverifiedPayloadPath, pszExpected, pszActual);
+        }
+        else
+        {
+            ExitOnFailure(hr, "Hash mismatch for path: %ls", wzUnverifiedPayloadPath);
+        }
+    }
+
+LExit:
+    ReleaseStr(pszActual);
+    ReleaseStr(pszExpected);
+
+    return hr;
+}
+
+static HRESULT VerifyPayloadWithCatalog(
+    __in BURN_PAYLOAD* pPayload,
+    __in_z LPCWSTR wzUnverifiedPayloadPath,
+    __in HANDLE hFile
+    )
+{
+    HRESULT hr = S_FALSE;
+    DWORD er = ERROR_SUCCESS;
+    WINTRUST_DATA WinTrustData = { };
+    WINTRUST_CATALOG_INFO WinTrustCatalogInfo = { };
+    GUID gSubSystemDriver = WINTRUST_ACTION_GENERIC_VERIFY_V2;
+    LPWSTR sczLowerCaseFile = NULL;
+    LPWSTR pCurrent = NULL;
+    LPWSTR sczName = NULL;
+    DWORD dwHashSize = 0;
+    DWORD dwTagSize;
+    LPBYTE pbHash = NULL;
+
+    // Get lower case file name.  Older operating systems need a lower case file
+    // to match in the catalog
+    hr = StrAllocString(&sczLowerCaseFile, wzUnverifiedPayloadPath, 0);
+    ExitOnFailure(hr, "Failed to allocate memory");
+
+    // Go through each character doing the lower case of each letter
+    pCurrent = sczLowerCaseFile;
+    while ('\0' != *pCurrent)
+    {
+        *pCurrent = (WCHAR)_tolower(*pCurrent);
+        pCurrent++;
+    }
+
+    // Get file hash
+    CryptCATAdminCalcHashFromFileHandle(hFile, &dwHashSize, pbHash, 0);
+    er = ::GetLastError();
+    if (ERROR_INSUFFICIENT_BUFFER == er)
+    {
+        pbHash = (LPBYTE)MemAlloc(dwHashSize, TRUE);
+        if (!CryptCATAdminCalcHashFromFileHandle(hFile, &dwHashSize, pbHash, 0))
+        {
+            ExitWithLastError(hr, "Failed to get file hash.");
+        }
+    }
+    else
+    {
+        ExitOnWin32Error(er, hr, "Failed to get file hash.");
+    }
+
+    // Make the hash into a string.  This is the member tag for the catalog
+    dwTagSize = (dwHashSize * 2) + 1;
+    hr = StrAlloc(&sczName, dwTagSize);
+    ExitOnFailure(hr, "Failed to allocate string.");
+    hr = StrHexEncode(pbHash, dwHashSize, sczName, dwTagSize);
+    ExitOnFailure(hr, "Failed to encode file hash.");
+
+    // Set up the WinVerifyTrust structures assuming online.
+    WinTrustData.cbStruct = sizeof(WINTRUST_DATA);
+    WinTrustData.dwUIChoice = WTD_UI_NONE;
+    WinTrustData.dwUnionChoice = WTD_CHOICE_CATALOG;
+    WinTrustData.dwStateAction = WTD_STATEACTION_VERIFY;
+    WinTrustData.dwProvFlags = WTD_REVOCATION_CHECK_CHAIN_EXCLUDE_ROOT;
+    WinTrustData.pCatalog = &WinTrustCatalogInfo;
+
+    WinTrustCatalogInfo.cbStruct = sizeof(WINTRUST_CATALOG_INFO);
+    WinTrustCatalogInfo.pbCalculatedFileHash = pbHash;
+    WinTrustCatalogInfo.cbCalculatedFileHash = dwHashSize;
+    WinTrustCatalogInfo.hMemberFile = hFile;
+    WinTrustCatalogInfo.pcwszMemberTag = sczName;
+    WinTrustCatalogInfo.pcwszMemberFilePath = sczLowerCaseFile;
+    WinTrustCatalogInfo.pcwszCatalogFilePath = pPayload->pCatalog->sczLocalFilePath;
+
+    hr = ::WinVerifyTrust(static_cast<HWND>(INVALID_HANDLE_VALUE), &gSubSystemDriver, &WinTrustData);
+    if (hr)
+    {
+        // Set up the WinVerifyTrust structures assuming online.
+        WinTrustData.dwProvFlags |= WTD_CACHE_ONLY_URL_RETRIEVAL;
+
+        er = ::WinVerifyTrust(static_cast<HWND>(INVALID_HANDLE_VALUE), &gSubSystemDriver, &WinTrustData);
+
+        // WinVerifyTrust returns 0 for success, a few different Win32 error codes if it can't
+        // find the provider, and any other error code is provider specific, so may not
+        // be an actual Win32 error code
+        ExitOnWin32Error(er, hr, "Could not verify file %ls.", wzUnverifiedPayloadPath);
+    }
+
+    // Need to close the WinVerifyTrust action
+    WinTrustData.dwStateAction = WTD_STATEACTION_CLOSE;
+    er = ::WinVerifyTrust(static_cast<HWND>(INVALID_HANDLE_VALUE), &gSubSystemDriver, &WinTrustData);
+    ExitOnWin32Error(er, hr, "Could not close verify handle.");
+
+LExit:
+    ReleaseStr(sczLowerCaseFile);
+    ReleaseStr(sczName);
+    ReleaseMem(pbHash);
+
+    return hr;
+}
+
+static HRESULT VerifyPayloadAgainstChain(
+    __in BURN_PAYLOAD* pPayload,
+    __in PCCERT_CHAIN_CONTEXT pChainContext
+    )
+{
+    HRESULT hr = S_OK;
+    PCCERT_CONTEXT pChainElementCertContext = NULL;
+
+    BYTE rgbPublicKeyIdentifier[SHA1_HASH_LEN] = { };
+    DWORD cbPublicKeyIdentifier = sizeof(rgbPublicKeyIdentifier);
+    BYTE* pbThumbprint = NULL;
+    DWORD cbThumbprint = 0;
+
+    // Walk up the chain looking for a certificate in the chain that matches our expected public key identifier
+    // and thumbprint (if a thumbprint was provided).
+    HRESULT hrChainVerification = E_NOTFOUND; // assume we won't find a match.
+    for (DWORD i = 0; i < pChainContext->rgpChain[0]->cElement; ++i)
+    {
+        pChainElementCertContext = pChainContext->rgpChain[0]->rgpElement[i]->pCertContext;
+
+        // Get the certificate's public key identifier.
+        if (!::CryptHashPublicKeyInfo(NULL, CALG_SHA1, 0, X509_ASN_ENCODING, &pChainElementCertContext->pCertInfo->SubjectPublicKeyInfo, rgbPublicKeyIdentifier, &cbPublicKeyIdentifier))
+        {
+            ExitWithLastError(hr, "Failed to get certificate public key identifier.");
+        }
+
+        // Compare the certificate's public key identifier with the payload's public key identifier. If they
+        // match, we're one step closer to the a positive result.
+        if (pPayload->cbCertificateRootPublicKeyIdentifier == cbPublicKeyIdentifier &&
+            0 == memcmp(pPayload->pbCertificateRootPublicKeyIdentifier, rgbPublicKeyIdentifier, cbPublicKeyIdentifier))
+        {
+            // If the payload specified a thumbprint for the certificate, verify it.
+            if (pPayload->pbCertificateRootThumbprint)
+            {
+                hr = CertReadProperty(pChainElementCertContext, CERT_SHA1_HASH_PROP_ID, &pbThumbprint, &cbThumbprint);
+                ExitOnFailure(hr, "Failed to read certificate thumbprint.");
+
+                if (pPayload->cbCertificateRootThumbprint == cbThumbprint &&
+                    0 == memcmp(pPayload->pbCertificateRootThumbprint, pbThumbprint, cbThumbprint))
+                {
+                    // If we got here, we found that our payload public key identifier and thumbprint
+                    // matched an element in the certficate chain.
+                    hrChainVerification = S_OK;
+                    break;
+                }
+
+                ReleaseNullMem(pbThumbprint);
+            }
+            else // no thumbprint match necessary so we're good to go.
+            {
+                hrChainVerification = S_OK;
+                break;
+            }
+        }
+    }
+    hr = hrChainVerification;
+    ExitOnFailure(hr, "Failed to find expected public key in certificate chain.");
+
+LExit:
+    ReleaseMem(pbThumbprint);
+
+    return hr;
+}
diff --git a/src/engine/cache.h b/src/engine/cache.h
new file mode 100644
index 00000000..95e6cb90
--- /dev/null
+++ b/src/engine/cache.h
@@ -0,0 +1,150 @@
+#pragma once
+// 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.
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// structs
+
+// functions
+
+HRESULT CacheInitialize(
+    __in BURN_REGISTRATION* pRegistration,
+    __in BURN_VARIABLES* pVariables,
+    __in_z_opt LPCWSTR wzSourceProcessPath
+    );
+HRESULT CacheEnsureWorkingFolder(
+    __in LPCWSTR wzBundleId,
+    __deref_out_z_opt LPWSTR* psczWorkingFolder
+    );
+HRESULT CacheCalculateBundleWorkingPath(
+    __in_z LPCWSTR wzBundleId,
+    __in LPCWSTR wzExecutableName,
+    __deref_out_z LPWSTR* psczWorkingPath
+    );
+HRESULT CacheCalculateBundleLayoutWorkingPath(
+    __in_z LPCWSTR wzBundleId,
+    __deref_out_z LPWSTR* psczWorkingPath
+    );
+HRESULT CacheCalculatePayloadWorkingPath(
+    __in_z LPCWSTR wzBundleId,
+    __in BURN_PAYLOAD* pPayload,
+    __deref_out_z LPWSTR* psczWorkingPath
+    );
+HRESULT CacheCalculateContainerWorkingPath(
+    __in_z LPCWSTR wzBundleId,
+    __in BURN_CONTAINER* pContainer,
+    __deref_out_z LPWSTR* psczWorkingPath
+    );
+HRESULT CacheGetRootCompletedPath(
+    __in BOOL fPerMachine,
+    __in BOOL fForceInitialize,
+    __deref_out_z LPWSTR* psczRootCompletedPath
+    );
+HRESULT CacheGetCompletedPath(
+    __in BOOL fPerMachine,
+    __in_z LPCWSTR wzCacheId,
+    __deref_out_z LPWSTR* psczCompletedPath
+    );
+HRESULT CacheGetResumePath(
+    __in_z LPCWSTR wzPayloadWorkingPath,
+    __deref_out_z LPWSTR* psczResumePath
+    );
+HRESULT CacheFindLocalSource(
+    __in_z LPCWSTR wzSourcePath,
+    __in BURN_VARIABLES* pVariables,
+    __out BOOL* pfFound,
+    __out_z LPWSTR* psczSourceFullPath
+    );
+HRESULT CacheSetLastUsedSource(
+    __in BURN_VARIABLES* pVariables,
+    __in_z LPCWSTR wzSourcePath,
+    __in_z LPCWSTR wzRelativePath
+    );
+HRESULT CacheSendProgressCallback(
+    __in DOWNLOAD_CACHE_CALLBACK* pCallback,
+    __in DWORD64 dw64Progress,
+    __in DWORD64 dw64Total,
+    __in HANDLE hDestinationFile
+    );
+void CacheSendErrorCallback(
+    __in DOWNLOAD_CACHE_CALLBACK* pCallback,
+    __in HRESULT hrError,
+    __in_z_opt LPCWSTR wzError,
+    __out_opt BOOL* pfRetry
+    );
+BOOL CacheBundleRunningFromCache();
+HRESULT CacheBundleToCleanRoom(
+    __in BURN_PAYLOADS* pUxPayloads,
+    __in BURN_SECTION* pSection,
+    __deref_out_z_opt LPWSTR* psczCleanRoomBundlePath
+    );
+HRESULT CacheBundleToWorkingDirectory(
+    __in_z LPCWSTR wzBundleId,
+    __in_z LPCWSTR wzExecutableName,
+    __in BURN_PAYLOADS* pUxPayloads,
+    __in BURN_SECTION* pSection,
+    __deref_out_z_opt LPWSTR* psczEngineWorkingPath
+    );
+HRESULT CacheLayoutBundle(
+    __in_z LPCWSTR wzExecutableName,
+    __in_z LPCWSTR wzLayoutDirectory,
+    __in_z LPCWSTR wzSourceBundlePath
+    );
+HRESULT CacheCompleteBundle(
+    __in BOOL fPerMachine,
+    __in_z LPCWSTR wzExecutableName,
+    __in_z LPCWSTR wzBundleId,
+    __in BURN_PAYLOADS* pUxPayloads,
+    __in_z LPCWSTR wzSourceBundlePath
+#ifdef DEBUG
+    , __in_z LPCWSTR wzExecutablePath
+#endif
+    );
+HRESULT CacheLayoutContainer(
+    __in BURN_CONTAINER* pContainer,
+    __in_z_opt LPCWSTR wzLayoutDirectory,
+    __in_z LPCWSTR wzUnverifiedContainerPath,
+    __in BOOL fMove
+    );
+HRESULT CacheLayoutPayload(
+    __in BURN_PAYLOAD* pPayload,
+    __in_z_opt LPCWSTR wzLayoutDirectory,
+    __in_z LPCWSTR wzUnverifiedPayloadPath,
+    __in BOOL fMove
+    );
+HRESULT CacheCompletePayload(
+    __in BOOL fPerMachine,
+    __in BURN_PAYLOAD* pPayload,
+    __in_z_opt LPCWSTR wzCacheId,
+    __in_z LPCWSTR wzUnverifiedPayloadPath,
+    __in BOOL fMove
+    );
+HRESULT CacheRemoveWorkingFolder(
+    __in_z_opt LPCWSTR wzBundleId
+    );
+HRESULT CacheRemoveBundle(
+    __in BOOL fPerMachine,
+    __in_z LPCWSTR wzPackageId
+    );
+HRESULT CacheRemovePackage(
+    __in BOOL fPerMachine,
+    __in_z LPCWSTR wzPackageId,
+    __in_z LPCWSTR wzCacheId
+    );
+HRESULT CacheVerifyPayloadSignature(
+    __in BURN_PAYLOAD* pPayload,
+    __in_z LPCWSTR wzUnverifiedPayloadPath,
+    __in HANDLE hFile
+    );
+void CacheCleanup(
+    __in BOOL fPerMachine,
+    __in_z LPCWSTR wzBundleId
+    );
+void CacheUninitialize();
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/engine/catalog.cpp b/src/engine/catalog.cpp
new file mode 100644
index 00000000..da086545
--- /dev/null
+++ b/src/engine/catalog.cpp
@@ -0,0 +1,180 @@
+// 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.
+
+#include "precomp.h"
+
+
+// function definitions
+
+extern "C" HRESULT CatalogsParseFromXml(
+    __in BURN_CATALOGS* pCatalogs,
+    __in IXMLDOMNode* pixnBundle
+    )
+{
+    HRESULT hr = S_OK;
+    IXMLDOMNodeList* pixnNodes = NULL;
+    IXMLDOMNode* pixnNode = NULL;
+    DWORD cNodes = 0;
+    LPWSTR scz = NULL;
+
+    // select catalog nodes
+    hr = XmlSelectNodes(pixnBundle, L"Catalog", &pixnNodes);
+    ExitOnFailure(hr, "Failed to select catalog nodes.");
+
+    // get catalog node count
+    hr = pixnNodes->get_length((long*)&cNodes);
+    ExitOnFailure(hr, "Failed to get payload node count.");
+    if (!cNodes)
+    {
+        ExitFunction();
+    }
+
+    // allocate memory for catalogs
+    pCatalogs->rgCatalogs = (BURN_CATALOG*)MemAlloc(sizeof(BURN_CATALOG) * cNodes, TRUE);
+    ExitOnNull(pCatalogs->rgCatalogs, hr, E_OUTOFMEMORY, "Failed to allocate memory for payload structs.");
+
+    pCatalogs->cCatalogs = cNodes;
+
+    // parse catalog elements
+    for (DWORD i = 0; i < cNodes; ++i)
+    {
+        BURN_CATALOG* pCatalog = &pCatalogs->rgCatalogs[i];
+        pCatalog->hFile = INVALID_HANDLE_VALUE;
+
+        hr = XmlNextElement(pixnNodes, &pixnNode, NULL);
+        ExitOnFailure(hr, "Failed to get next node.");
+
+        // @Id
+        hr = XmlGetAttributeEx(pixnNode, L"Id", &pCatalog->sczKey);
+        ExitOnFailure(hr, "Failed to get @Id.");
+
+        // @Payload
+        hr = XmlGetAttributeEx(pixnNode, L"Payload", &pCatalog->sczPayload);
+        ExitOnFailure(hr, "Failed to get @Payload.");
+
+        // prepare next iteration
+        ReleaseNullObject(pixnNode);
+    }
+
+LExit:
+    ReleaseObject(pixnNodes);
+    ReleaseObject(pixnNode);
+    ReleaseStr(scz);
+
+    return hr;
+}
+
+extern "C" HRESULT CatalogFindById(
+    __in BURN_CATALOGS* pCatalogs,
+    __in_z LPCWSTR wzId,
+    __out BURN_CATALOG** ppCatalog
+    )
+{
+    HRESULT hr = S_OK;
+    BURN_CATALOG* pCatalog = NULL;
+
+    for (DWORD i = 0; i < pCatalogs->cCatalogs; ++i)
+    {
+        pCatalog = &pCatalogs->rgCatalogs[i];
+
+        if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, pCatalog->sczKey, -1, wzId, -1))
+        {
+            *ppCatalog = pCatalog;
+            ExitFunction1(hr = S_OK);
+        }
+    }
+
+    hr = E_NOTFOUND;
+
+LExit:
+    return hr;
+}
+
+extern "C" HRESULT CatalogLoadFromPayload(
+    __in BURN_CATALOGS* pCatalogs,
+    __in BURN_PAYLOADS* pPayloads
+    )
+{
+    HRESULT hr = S_OK;
+    BURN_CATALOG* pCatalog = NULL;
+    BURN_PAYLOAD* pPayload = NULL;
+
+    // go through each catalog file
+    for (DWORD i = 0; i < pCatalogs->cCatalogs; i++)
+    {
+        pCatalog = &pCatalogs->rgCatalogs[i];
+
+        // get the payload for this catalog file
+        hr = PayloadFindById(pPayloads, pCatalog->sczPayload, &pPayload);
+        ExitOnFailure(hr, "Failed to find payload for catalog file.");
+
+        // Get the local file name
+        hr = StrAllocString(&pCatalog->sczLocalFilePath, pPayload->sczLocalFilePath, 0);
+        ExitOnFailure(hr, "Failed to get catalog local file path");
+
+        // Get a handle to the file
+        pCatalog->hFile = ::CreateFileW(pCatalog->sczLocalFilePath, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_DELETE, NULL, OPEN_EXISTING, FILE_FLAG_SEQUENTIAL_SCAN, NULL);
+        if (INVALID_HANDLE_VALUE == pCatalog->hFile)
+        {
+            ExitWithLastError(hr, "Failed to open catalog in working path: %ls", pCatalog->sczLocalFilePath);
+        }
+
+        // Verify the catalog file
+        hr = CacheVerifyPayloadSignature(pPayload, pCatalog->sczLocalFilePath, pCatalog->hFile);
+        ExitOnFailure(hr, "Failed to verify catalog signature: %ls", pCatalog->sczLocalFilePath);
+    }
+
+LExit:
+    return hr;
+}
+
+extern "C" HRESULT CatalogElevatedUpdateCatalogFile(
+    __in BURN_CATALOGS* pCatalogs,
+    __in_z LPCWSTR wzId,
+    __in_z LPCWSTR wzPath
+    )
+{
+    HRESULT hr = S_OK;
+    BURN_CATALOG* pCatalog = NULL;
+
+    // Find the catalog
+    hr = CatalogFindById(pCatalogs, wzId, &pCatalog);
+    ExitOnFailure(hr, "Failed to locate catalog information.");
+
+    if (NULL == pCatalog->sczLocalFilePath)
+    {
+        hr = StrAllocString(&pCatalog->sczLocalFilePath, wzPath, 0);
+        ExitOnFailure(hr, "Failed to allocated catalog path.");
+
+        // Get a handle to the file
+        pCatalog->hFile = ::CreateFileW(pCatalog->sczLocalFilePath, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_DELETE, NULL, OPEN_EXISTING, FILE_FLAG_SEQUENTIAL_SCAN, NULL);
+        if (INVALID_HANDLE_VALUE == pCatalog->hFile)
+        {
+            ExitWithLastError(hr, "Failed to open catalog in working path: %ls", pCatalog->sczLocalFilePath);
+        }
+    }
+
+LExit:
+    return hr;
+}
+
+extern "C" void CatalogUninitialize(
+    __in BURN_CATALOGS* pCatalogs
+    )
+{
+    if (pCatalogs->rgCatalogs)
+    {
+        for (DWORD i = 0; i < pCatalogs->cCatalogs; ++i)
+        {
+            BURN_CATALOG* pCatalog = &pCatalogs->rgCatalogs[i];
+
+            ReleaseHandle(pCatalog->hFile);
+            ReleaseStr(pCatalog->sczKey);
+            ReleaseStr(pCatalog->sczLocalFilePath);
+            ReleaseStr(pCatalog->sczPayload);
+        }
+        MemFree(pCatalogs->rgCatalogs);
+    }
+
+    // clear struct
+    memset(pCatalogs, 0, sizeof(BURN_CATALOGS));
+}
diff --git a/src/engine/catalog.h b/src/engine/catalog.h
new file mode 100644
index 00000000..3a87d0d2
--- /dev/null
+++ b/src/engine/catalog.h
@@ -0,0 +1,56 @@
+#pragma once
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+// structs
+
+typedef struct _BURN_CATALOG
+{
+    LPWSTR sczKey;
+    LPWSTR sczPayload;
+
+    // mutable members
+    LPWSTR sczLocalFilePath; // location of extracted or downloaded copy
+    HANDLE hFile;
+} BURN_CATALOG;
+
+typedef struct _BURN_CATALOGS
+{
+    BURN_CATALOG* rgCatalogs;
+    DWORD cCatalogs;
+} BURN_CATALOGS;
+
+typedef struct _BURN_PAYLOADS BURN_PAYLOADS;
+
+
+// functions
+
+HRESULT CatalogsParseFromXml(
+    __in BURN_CATALOGS* pCatalogs,
+    __in IXMLDOMNode* pixnBundle
+    );
+HRESULT CatalogFindById(
+    __in BURN_CATALOGS* pCatalogs,
+    __in_z LPCWSTR wzId,
+    __out BURN_CATALOG** ppCatalog
+    );
+HRESULT CatalogLoadFromPayload(
+    __in BURN_CATALOGS* pCatalogs,
+    __in BURN_PAYLOADS* pPayloads
+    );
+HRESULT CatalogElevatedUpdateCatalogFile(
+    __in BURN_CATALOGS* pCatalogs,
+    __in_z LPCWSTR wzId,
+    __in_z LPCWSTR wzPath
+    );
+void CatalogUninitialize(
+    __in BURN_CATALOGS* pCatalogs
+    );
+
+#if defined(__cplusplus)
+}
+#endif
diff --git a/src/engine/condition.cpp b/src/engine/condition.cpp
new file mode 100644
index 00000000..28391d2d
--- /dev/null
+++ b/src/engine/condition.cpp
@@ -0,0 +1,1030 @@
+// 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.
+
+#include "precomp.h"
+
+
+//
+// parse rules
+//
+// value                variable | literal | integer | version
+// comparison-operator  < | > | <= | >= | = | <> | >< | << | >>
+// term                 value | value comparison-operator value | ( expression )
+// boolean-factor       term | NOT term
+// boolean-term         boolean-factor | boolean-factor AND boolean-term
+// expression           boolean-term | boolean-term OR expression
+//
+
+
+// constants
+
+#define COMPARISON  0x00010000
+#define INSENSITIVE 0x00020000
+
+enum BURN_SYMBOL_TYPE
+{
+    // terminals
+    BURN_SYMBOL_TYPE_NONE       =  0,
+    BURN_SYMBOL_TYPE_END        =  1,
+    BURN_SYMBOL_TYPE_OR         =  2,                               // OR
+    BURN_SYMBOL_TYPE_AND        =  3,                               // AND
+    BURN_SYMBOL_TYPE_NOT        =  4,                               // NOT
+    BURN_SYMBOL_TYPE_LT         =  5 | COMPARISON,                  // <
+    BURN_SYMBOL_TYPE_GT         =  6 | COMPARISON,                  // >
+    BURN_SYMBOL_TYPE_LE         =  7 | COMPARISON,                  // <=
+    BURN_SYMBOL_TYPE_GE         =  8 | COMPARISON,                  // >=
+    BURN_SYMBOL_TYPE_EQ         =  9 | COMPARISON,                  // =
+    BURN_SYMBOL_TYPE_NE         = 10 | COMPARISON,                  // <>
+    BURN_SYMBOL_TYPE_BAND       = 11 | COMPARISON,                  // ><
+    BURN_SYMBOL_TYPE_HIEQ       = 12 | COMPARISON,                  // <<
+    BURN_SYMBOL_TYPE_LOEQ       = 13 | COMPARISON,                  // >>
+    BURN_SYMBOL_TYPE_LT_I       =  5 | COMPARISON | INSENSITIVE,    // ~<
+    BURN_SYMBOL_TYPE_GT_I       =  6 | COMPARISON | INSENSITIVE,    // ~>
+    BURN_SYMBOL_TYPE_LE_I       =  7 | COMPARISON | INSENSITIVE,    // ~<=
+    BURN_SYMBOL_TYPE_GE_I       =  8 | COMPARISON | INSENSITIVE,    // ~>=
+    BURN_SYMBOL_TYPE_EQ_I       =  9 | COMPARISON | INSENSITIVE,    // ~=
+    BURN_SYMBOL_TYPE_NE_I       = 10 | COMPARISON | INSENSITIVE,    // ~<>
+    BURN_SYMBOL_TYPE_BAND_I     = 11 | COMPARISON | INSENSITIVE,    // ~><
+    BURN_SYMBOL_TYPE_HIEQ_I     = 12 | COMPARISON | INSENSITIVE,    // ~<<
+    BURN_SYMBOL_TYPE_LOEQ_I     = 13 | COMPARISON | INSENSITIVE,    // ~>>
+    BURN_SYMBOL_TYPE_LPAREN     = 14,                               // (
+    BURN_SYMBOL_TYPE_RPAREN     = 15,                               // )
+    BURN_SYMBOL_TYPE_NUMBER     = 16,
+    BURN_SYMBOL_TYPE_IDENTIFIER = 17,
+    BURN_SYMBOL_TYPE_LITERAL    = 18,
+    BURN_SYMBOL_TYPE_VERSION    = 19,
+};
+
+
+// structs
+
+struct BURN_SYMBOL
+{
+    BURN_SYMBOL_TYPE Type;
+    DWORD iPosition;
+    BURN_VARIANT Value;
+};
+
+struct BURN_CONDITION_PARSE_CONTEXT
+{
+    BURN_VARIABLES* pVariables;
+    LPCWSTR wzCondition;
+    LPCWSTR wzRead;
+    BURN_SYMBOL NextSymbol;
+    BOOL fError;
+};
+
+
+// internal function declarations
+
+static HRESULT ParseExpression(
+    __in BURN_CONDITION_PARSE_CONTEXT* pContext,
+    __out BOOL* pf
+    );
+static HRESULT ParseBooleanTerm(
+    __in BURN_CONDITION_PARSE_CONTEXT* pContext,
+    __out BOOL* pf
+    );
+static HRESULT ParseBooleanFactor(
+    __in BURN_CONDITION_PARSE_CONTEXT* pContext,
+    __out BOOL* pf
+    );
+static HRESULT ParseTerm(
+    __in BURN_CONDITION_PARSE_CONTEXT* pContext,
+    __out BOOL* pf
+    );
+static HRESULT ParseValue(
+    __in BURN_CONDITION_PARSE_CONTEXT* pContext,
+    __out BURN_VARIANT* pValue
+    );
+static HRESULT Expect(
+    __in BURN_CONDITION_PARSE_CONTEXT* pContext,
+    __in BURN_SYMBOL_TYPE symbolType
+    );
+static HRESULT NextSymbol(
+    __in BURN_CONDITION_PARSE_CONTEXT* pContext
+    );
+static HRESULT CompareValues(
+    __in BURN_SYMBOL_TYPE comparison,
+    __in BURN_VARIANT leftOperand,
+    __in BURN_VARIANT rightOperand,
+    __out BOOL* pfResult
+    );
+static HRESULT CompareStringValues(
+    __in BURN_SYMBOL_TYPE comparison,
+    __in_z LPCWSTR wzLeftOperand,
+    __in_z LPCWSTR wzRightOperand,
+    __out BOOL* pfResult
+    );
+static HRESULT CompareIntegerValues(
+    __in BURN_SYMBOL_TYPE comparison,
+    __in LONGLONG llLeftOperand,
+    __in LONGLONG llRightOperand,
+    __out BOOL* pfResult
+    );
+static HRESULT CompareVersionValues(
+    __in BURN_SYMBOL_TYPE comparison,
+    __in DWORD64 qwLeftOperand,
+    __in DWORD64 qwRightOperand,
+    __out BOOL* pfResult
+    );
+
+
+// function definitions
+
+extern "C" HRESULT ConditionEvaluate(
+    __in BURN_VARIABLES* pVariables,
+    __in_z LPCWSTR wzCondition,
+    __out BOOL* pf
+    )
+{
+    HRESULT hr = S_OK;
+    BURN_CONDITION_PARSE_CONTEXT context = { };
+    BOOL f = FALSE;
+
+    context.pVariables = pVariables;
+    context.wzCondition = wzCondition;
+    context.wzRead = wzCondition;
+
+    hr = NextSymbol(&context);
+    ExitOnFailure(hr, "Failed to read next symbol.");
+
+    hr = ParseExpression(&context, &f);
+    ExitOnFailure(hr, "Failed to parse expression.");
+
+    hr = Expect(&context, BURN_SYMBOL_TYPE_END);
+    ExitOnFailure(hr, "Failed to expect end symbol.");
+
+    LogId(REPORT_VERBOSE, MSG_CONDITION_RESULT, wzCondition, LoggingTrueFalseToString(f));
+
+    *pf = f;
+    hr = S_OK;
+
+LExit:
+    if (context.fError)
+    {
+        Assert(FAILED(hr));
+        LogErrorId(hr, MSG_FAILED_PARSE_CONDITION, wzCondition, NULL, NULL);
+    }
+
+    return hr;
+}
+
+extern "C" HRESULT ConditionGlobalCheck(
+    __in BURN_VARIABLES* pVariables,
+    __in BURN_CONDITION* pCondition,
+    __in BOOTSTRAPPER_DISPLAY display,
+    __in_z LPCWSTR wzBundleName,
+    __out DWORD *pdwExitCode,
+    __out BOOL *pfContinueExecution
+    )
+{
+    HRESULT hr = S_OK;
+    BOOL fSuccess = TRUE;
+    HRESULT hrError = HRESULT_FROM_WIN32(ERROR_OLD_WIN_VERSION);
+    OS_VERSION osv = OS_VERSION_UNKNOWN;
+    DWORD dwServicePack = 0;
+
+    OsGetVersion(&osv, &dwServicePack);
+
+    // Always error on Windows 2000 or lower
+    if (OS_VERSION_WIN2000 >= osv)
+    {
+        fSuccess = FALSE;
+    }
+    else
+    {
+        if (NULL != pCondition->sczConditionString)
+        {
+            hr = ConditionEvaluate(pVariables, pCondition->sczConditionString, &fSuccess);
+            ExitOnFailure(hr, "Failed to evaluate condition: %ls", pCondition->sczConditionString);
+        }
+    }
+
+    if (!fSuccess)
+    {
+        // Display the error messagebox, as long as we're in an appropriate display mode
+        hr = SplashScreenDisplayError(display, wzBundleName, hrError);
+        ExitOnFailure(hr, "Failed to display error dialog");
+
+        *pdwExitCode = static_cast<DWORD>(hrError);
+        *pfContinueExecution = FALSE;
+    }
+
+LExit:
+    return hr;
+}
+
+HRESULT ConditionGlobalParseFromXml(
+    __in BURN_CONDITION* pCondition,
+    __in IXMLDOMNode* pixnBundle
+    )
+{
+    HRESULT hr = S_OK;
+    IXMLDOMNode* pixnNode = NULL;
+    BSTR bstrExpression = NULL;
+
+    // select variable nodes
+    hr = XmlSelectSingleNode(pixnBundle, L"Condition", &pixnNode);
+    if (S_FALSE == hr)
+    {
+        ExitFunction1(hr = S_OK);
+    }
+    ExitOnFailure(hr, "Failed to select condition node.");
+
+    // @Condition
+    hr = XmlGetText(pixnNode, &bstrExpression);
+    ExitOnFailure(hr, "Failed to get Condition inner text.");
+
+    hr = StrAllocString(&pCondition->sczConditionString, bstrExpression, 0);
+    ExitOnFailure(hr, "Failed to copy condition string from BSTR");
+
+LExit:
+    ReleaseBSTR(bstrExpression);
+    ReleaseObject(pixnNode);
+
+    return hr;
+}
+
+
+// internal function definitions
+
+static HRESULT ParseExpression(
+    __in BURN_CONDITION_PARSE_CONTEXT* pContext,
+    __out BOOL* pf
+    )
+{
+    HRESULT hr = S_OK;
+    BOOL fFirst = FALSE;
+    BOOL fSecond = FALSE;
+
+    hr = ParseBooleanTerm(pContext, &fFirst);
+    ExitOnFailure(hr, "Failed to parse boolean-term.");
+
+    if (BURN_SYMBOL_TYPE_OR == pContext->NextSymbol.Type)
+    {
+        hr = NextSymbol(pContext);
+        ExitOnFailure(hr, "Failed to read next symbol.");
+
+        hr = ParseExpression(pContext, &fSecond);
+        ExitOnFailure(hr, "Failed to parse expression.");
+
+        *pf = fFirst || fSecond;
+    }
+    else
+    {
+        *pf = fFirst;
+    }
+
+LExit:
+    return hr;
+}
+
+static HRESULT ParseBooleanTerm(
+    __in BURN_CONDITION_PARSE_CONTEXT* pContext,
+    __out BOOL* pf
+    )
+{
+    HRESULT hr = S_OK;
+    BOOL fFirst = FALSE;
+    BOOL fSecond = FALSE;
+
+    hr = ParseBooleanFactor(pContext, &fFirst);
+    ExitOnFailure(hr, "Failed to parse boolean-factor.");
+
+    if (BURN_SYMBOL_TYPE_AND == pContext->NextSymbol.Type)
+    {
+        hr = NextSymbol(pContext);
+        ExitOnFailure(hr, "Failed to read next symbol.");
+
+        hr = ParseBooleanTerm(pContext, &fSecond);
+        ExitOnFailure(hr, "Failed to parse boolean-term.");
+
+        *pf = fFirst && fSecond;
+    }
+    else
+    {
+        *pf = fFirst;
+    }
+
+LExit:
+    return hr;
+}
+
+static HRESULT ParseBooleanFactor(
+    __in BURN_CONDITION_PARSE_CONTEXT* pContext,
+    __out BOOL* pf
+    )
+{
+    HRESULT hr = S_OK;
+    BOOL fNot = FALSE;
+    BOOL f = FALSE;
+
+    if (BURN_SYMBOL_TYPE_NOT == pContext->NextSymbol.Type)
+    {
+        hr = NextSymbol(pContext);
+        ExitOnFailure(hr, "Failed to read next symbol.");
+
+        fNot = TRUE;
+    }
+
+    hr = ParseTerm(pContext, &f);
+    ExitOnFailure(hr, "Failed to parse term.");
+
+    *pf = fNot ? !f : f;
+
+LExit:
+    return hr;
+}
+
+static HRESULT ParseTerm(
+    __in BURN_CONDITION_PARSE_CONTEXT* pContext,
+    __out BOOL* pf
+    )
+{
+    HRESULT hr = S_OK;
+    BURN_VARIANT firstValue = { };
+    BURN_VARIANT secondValue = { };
+
+    if (BURN_SYMBOL_TYPE_LPAREN == pContext->NextSymbol.Type)
+    {
+        hr = NextSymbol(pContext);
+        ExitOnFailure(hr, "Failed to read next symbol.");
+
+        hr = ParseExpression(pContext, pf);
+        ExitOnFailure(hr, "Failed to parse expression.");
+
+        hr = Expect(pContext, BURN_SYMBOL_TYPE_RPAREN);
+        ExitOnFailure(hr, "Failed to expect right parenthesis.");
+
+        ExitFunction1(hr = S_OK);
+    }
+
+    hr = ParseValue(pContext, &firstValue);
+    ExitOnFailure(hr, "Failed to parse value.");
+
+    if (COMPARISON & pContext->NextSymbol.Type)
+    {
+        BURN_SYMBOL_TYPE comparison = pContext->NextSymbol.Type;
+
+        hr = NextSymbol(pContext);
+        ExitOnFailure(hr, "Failed to read next symbol.");
+
+        hr = ParseValue(pContext, &secondValue);
+        ExitOnFailure(hr, "Failed to parse value.");
+
+        hr = CompareValues(comparison, firstValue, secondValue, pf);
+        ExitOnFailure(hr, "Failed to compare value.");
+    }
+    else
+    {
+        LONGLONG llValue = 0;
+        LPWSTR sczValue = NULL;
+        DWORD64 qwValue = 0;
+        switch (firstValue.Type)
+        {
+        case BURN_VARIANT_TYPE_NONE:
+            *pf = FALSE;
+            break;
+        case BURN_VARIANT_TYPE_STRING:
+            hr = BVariantGetString(&firstValue, &sczValue);
+            if (SUCCEEDED(hr))
+            {
+                *pf = sczValue && *sczValue;
+            }
+            StrSecureZeroFreeString(sczValue);
+            break;
+        case BURN_VARIANT_TYPE_NUMERIC:
+            hr = BVariantGetNumeric(&firstValue, &llValue);
+            if (SUCCEEDED(hr))
+            {
+                *pf = 0 != llValue;
+            }
+            SecureZeroMemory(&llValue, sizeof(llValue));
+            break;
+        case BURN_VARIANT_TYPE_VERSION:
+            hr = BVariantGetVersion(&firstValue, &qwValue);
+            if (SUCCEEDED(hr))
+            {
+                *pf = 0 != qwValue;
+            }
+            SecureZeroMemory(&llValue, sizeof(qwValue));
+            break;
+        default:
+            ExitFunction1(hr = E_UNEXPECTED);
+        }
+    }
+
+LExit:
+    BVariantUninitialize(&firstValue);
+    BVariantUninitialize(&secondValue);
+    return hr;
+}
+
+static HRESULT ParseValue(
+    __in BURN_CONDITION_PARSE_CONTEXT* pContext,
+    __out BURN_VARIANT* pValue
+    )
+{
+    HRESULT hr = S_OK;
+
+    // Symbols don't encrypt their value, so can access the value directly.
+    switch (pContext->NextSymbol.Type)
+    {
+    case BURN_SYMBOL_TYPE_IDENTIFIER:
+        Assert(BURN_VARIANT_TYPE_STRING == pContext->NextSymbol.Value.Type);
+
+        // find variable
+        hr = VariableGetVariant(pContext->pVariables, pContext->NextSymbol.Value.sczValue, pValue);
+        if (E_NOTFOUND != hr)
+        {
+            ExitOnRootFailure(hr, "Failed to find variable.");
+        }
+        break;
+
+    case BURN_SYMBOL_TYPE_NUMBER: __fallthrough;
+    case BURN_SYMBOL_TYPE_LITERAL: __fallthrough;
+    case BURN_SYMBOL_TYPE_VERSION:
+        // steal value of symbol
+        memcpy_s(pValue, sizeof(BURN_VARIANT), &pContext->NextSymbol.Value, sizeof(BURN_VARIANT));
+        memset(&pContext->NextSymbol.Value, 0, sizeof(BURN_VARIANT));
+        break;
+
+    default:
+        pContext->fError = TRUE;
+        hr = E_INVALIDDATA;
+        ExitOnRootFailure(hr, "Failed to parse condition '%ls' at position: %u", pContext->wzCondition, pContext->NextSymbol.iPosition);
+    }
+
+    // get next symbol
+    hr = NextSymbol(pContext);
+    ExitOnFailure(hr, "Failed to read next symbol.");
+
+LExit:
+    return hr;
+}
+
+//
+// Expect - expects a symbol.
+//
+static HRESULT Expect(
+    __in BURN_CONDITION_PARSE_CONTEXT* pContext,
+    __in BURN_SYMBOL_TYPE symbolType
+    )
+{
+    HRESULT hr = S_OK;
+
+    if (pContext->NextSymbol.Type != symbolType)
+    {
+        pContext->fError = TRUE;
+        hr = E_INVALIDDATA;
+        ExitOnRootFailure(hr, "Failed to parse condition '%ls' at position: %u", pContext->wzCondition, pContext->NextSymbol.iPosition);
+    }
+
+    hr = NextSymbol(pContext);
+    ExitOnFailure(hr, "Failed to read next symbol.");
+
+LExit:
+    return hr;
+}
+
+//
+// NextSymbol - finds the next symbol in an expression string.
+//
+static HRESULT NextSymbol(
+    __in BURN_CONDITION_PARSE_CONTEXT* pContext
+    )
+{
+    HRESULT hr = S_OK;
+    WORD charType = 0;
+    DWORD iPosition = 0;
+    DWORD n = 0;
+
+    // free existing symbol
+    BVariantUninitialize(&pContext->NextSymbol.Value);
+    memset(&pContext->NextSymbol, 0, sizeof(BURN_SYMBOL));
+
+    // skip past blanks
+    while (L'\0' != pContext->wzRead[0])
+    {
+        ::GetStringTypeW(CT_CTYPE1, pContext->wzRead, 1, &charType);
+        if (0 == (C1_BLANK & charType))
+        {
+            break; // no blank, done
+        }
+        ++pContext->wzRead;
+    }
+    iPosition = (DWORD)(pContext->wzRead - pContext->wzCondition);
+
+    // read depending on first character type
+    switch (pContext->wzRead[0])
+    {
+    case L'\0':
+        pContext->NextSymbol.Type = BURN_SYMBOL_TYPE_END;
+        break;
+    case L'~':
+        switch (pContext->wzRead[1])
+        {
+        case L'=':
+            pContext->NextSymbol.Type = BURN_SYMBOL_TYPE_EQ_I;
+            n = 2;
+            break;
+        case L'>':
+            switch (pContext->wzRead[2])
+            {
+            case '=':
+                pContext->NextSymbol.Type = BURN_SYMBOL_TYPE_GE_I;
+                n = 3;
+                break;
+            case L'>':
+                pContext->NextSymbol.Type = BURN_SYMBOL_TYPE_LOEQ_I;
+                n = 3;
+                break;
+            case L'<':
+                pContext->NextSymbol.Type = BURN_SYMBOL_TYPE_BAND_I;
+                n = 3;
+                break;
+            default:
+                pContext->NextSymbol.Type = BURN_SYMBOL_TYPE_GT_I;
+                n = 2;
+            }
+            break;
+        case L'<':
+            switch (pContext->wzRead[2])
+            {
+            case '=':
+                pContext->NextSymbol.Type = BURN_SYMBOL_TYPE_LE_I;
+                n = 3;
+                break;
+            case L'<':
+                pContext->NextSymbol.Type = BURN_SYMBOL_TYPE_HIEQ_I;
+                n = 3;
+                break;
+            case '>':
+                pContext->NextSymbol.Type = BURN_SYMBOL_TYPE_NE_I;
+                n = 3;
+                break;
+            default:
+                pContext->NextSymbol.Type = BURN_SYMBOL_TYPE_LT_I;
+                n = 2;
+            }
+            break;
+        default:
+            // error
+            pContext->fError = TRUE;
+            hr = E_INVALIDDATA;
+            ExitOnRootFailure(hr, "Failed to parse condition \"%ls\". Unexpected '~' operator at position %d.", pContext->wzCondition, iPosition);
+        }
+        break;
+    case L'>':
+        switch (pContext->wzRead[1])
+        {
+        case L'=':
+            pContext->NextSymbol.Type = BURN_SYMBOL_TYPE_GE;
+            n = 2;
+            break;
+        case L'>':
+            pContext->NextSymbol.Type = BURN_SYMBOL_TYPE_LOEQ;
+            n = 2;
+            break;
+        case L'<':
+            pContext->NextSymbol.Type = BURN_SYMBOL_TYPE_BAND;
+            n = 2;
+            break;
+        default:
+            pContext->NextSymbol.Type = BURN_SYMBOL_TYPE_GT;
+            n = 1;
+        }
+        break;
+    case L'<':
+        switch (pContext->wzRead[1])
+        {
+        case L'=':
+            pContext->NextSymbol.Type = BURN_SYMBOL_TYPE_LE;
+            n = 2;
+            break;
+        case L'<':
+            pContext->NextSymbol.Type = BURN_SYMBOL_TYPE_HIEQ;
+            n = 2;
+            break;
+        case L'>':
+            pContext->NextSymbol.Type = BURN_SYMBOL_TYPE_NE;
+            n = 2;
+            break;
+        default:
+            pContext->NextSymbol.Type = BURN_SYMBOL_TYPE_LT;
+            n = 1;
+        }
+        break;
+    case L'=':
+        pContext->NextSymbol.Type = BURN_SYMBOL_TYPE_EQ;
+        n = 1;
+        break;
+    case L'(':
+        pContext->NextSymbol.Type = BURN_SYMBOL_TYPE_LPAREN;
+        n = 1;
+        break;
+    case L')':
+        pContext->NextSymbol.Type = BURN_SYMBOL_TYPE_RPAREN;
+        n = 1;
+        break;
+    case L'"': // literal
+        do
+        {
+            ++n;
+            if (L'\0' == pContext->wzRead[n])
+            {
+                // error
+                pContext->fError = TRUE;
+                hr = E_INVALIDDATA;
+                ExitOnRootFailure(hr, "Failed to parse condition \"%ls\". Unterminated literal at position %d.", pContext->wzCondition, iPosition);
+            }
+        } while (L'"' != pContext->wzRead[n]);
+        ++n; // terminating '"'
+
+        pContext->NextSymbol.Type = BURN_SYMBOL_TYPE_LITERAL;
+        hr = BVariantSetString(&pContext->NextSymbol.Value, &pContext->wzRead[1], n - 2);
+        ExitOnFailure(hr, "Failed to set symbol value.");
+        break;
+    default:
+        if (C1_DIGIT & charType || L'-' == pContext->wzRead[0])
+        {
+            do
+            {
+                ++n;
+                ::GetStringTypeW(CT_CTYPE1, &pContext->wzRead[n], 1, &charType);
+                if (C1_ALPHA & charType || L'_' == pContext->wzRead[n])
+                {
+                    // error, identifier cannot start with a digit
+                    pContext->fError = TRUE;
+                    hr = E_INVALIDDATA;
+                    ExitOnRootFailure(hr, "Failed to parse condition \"%ls\". Identifier cannot start at a digit, at position %d.", pContext->wzCondition, iPosition);
+                }
+            } while (C1_DIGIT & charType);
+
+            // number
+            pContext->NextSymbol.Type = BURN_SYMBOL_TYPE_NUMBER;
+
+            LONGLONG ll = 0;
+            hr = StrStringToInt64(pContext->wzRead, n, &ll);
+            if (FAILED(hr))
+            {
+                pContext->fError = TRUE;
+                hr = E_INVALIDDATA;
+                ExitOnRootFailure(hr, "Failed to parse condition \"%ls\". Constant too big, at position %d.", pContext->wzCondition, iPosition);
+            }
+
+            hr = BVariantSetNumeric(&pContext->NextSymbol.Value, ll);
+            ExitOnFailure(hr, "Failed to set symbol value.");
+        }
+        else if (C1_ALPHA & charType || L'_' == pContext->wzRead[0])
+        {
+            ::GetStringTypeW(CT_CTYPE1, &pContext->wzRead[1], 1, &charType);
+            if (L'v' == pContext->wzRead[0] && C1_DIGIT & charType)
+            {
+                // version
+                DWORD cParts = 1;
+                for (;;)
+                {
+                    ++n;
+                    if (L'.' == pContext->wzRead[n])
+                    {
+                        ++cParts;
+                        if (4 < cParts)
+                        {
+                            // error, too many parts in version
+                            pContext->fError = TRUE;
+                            hr = E_INVALIDDATA;
+                            ExitOnRootFailure(hr, "Failed to parse condition \"%ls\". Version can have a maximum of 4 parts, at position %d.", pContext->wzCondition, iPosition);
+                        }
+                    }
+                    else
+                    {
+                        ::GetStringTypeW(CT_CTYPE1, &pContext->wzRead[n], 1, &charType);
+                        if (C1_DIGIT != (C1_DIGIT & charType))
+                        {
+                            break;
+                        }
+                    }
+                }
+
+                // Symbols don't encrypt their value, so can access the value directly.
+                hr = FileVersionFromStringEx(&pContext->wzRead[1], n - 1, &pContext->NextSymbol.Value.qwValue);
+                if (FAILED(hr))
+                {
+                    pContext->fError = TRUE;
+                    hr = E_INVALIDDATA;
+                    ExitOnRootFailure(hr, "Failed to parse condition \"%ls\". Invalid version format, at position %d.", pContext->wzCondition, iPosition);
+                }
+
+                pContext->NextSymbol.Value.Type = BURN_VARIANT_TYPE_VERSION;
+                pContext->NextSymbol.Type = BURN_SYMBOL_TYPE_VERSION;
+            }
+            else
+            {
+                do
+                {
+                    ++n;
+                    ::GetStringTypeW(CT_CTYPE1, &pContext->wzRead[n], 1, &charType);
+                } while (C1_ALPHA & charType || C1_DIGIT & charType || L'_' == pContext->wzRead[n]);
+
+                if (2 == n && CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, NORM_IGNORECASE, pContext->wzRead, 2, L"OR", 2))
+                {
+                    // OR
+                    pContext->NextSymbol.Type = BURN_SYMBOL_TYPE_OR;
+                }
+                else if (3 == n && CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, NORM_IGNORECASE, pContext->wzRead, 3, L"AND", 3))
+                {
+                    // AND
+                    pContext->NextSymbol.Type = BURN_SYMBOL_TYPE_AND;
+                }
+                else if (3 == n && CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, NORM_IGNORECASE, pContext->wzRead, 3, L"NOT", 3))
+                {
+                    // NOT
+                    pContext->NextSymbol.Type = BURN_SYMBOL_TYPE_NOT;
+                }
+                else
+                {
+                    // identifier
+                    pContext->NextSymbol.Type = BURN_SYMBOL_TYPE_IDENTIFIER;
+                    hr = BVariantSetString(&pContext->NextSymbol.Value, pContext->wzRead, n);
+                    ExitOnFailure(hr, "Failed to set symbol value.");
+                }
+            }
+        }
+        else
+        {
+            // error, unexpected character
+            pContext->fError = TRUE;
+            hr = E_INVALIDDATA;
+            ExitOnRootFailure(hr, "Failed to parse condition \"%ls\". Unexpected character at position %d.", pContext->wzCondition, iPosition);
+        }
+    }
+    pContext->NextSymbol.iPosition = iPosition;
+    pContext->wzRead += n;
+
+LExit:
+    return hr;
+}
+
+//
+// CompareValues - compares two variant values using a given comparison.
+//
+static HRESULT CompareValues(
+    __in BURN_SYMBOL_TYPE comparison,
+    __in BURN_VARIANT leftOperand,
+    __in BURN_VARIANT rightOperand,
+    __out BOOL* pfResult
+    )
+{
+    HRESULT hr = S_OK;
+    LONGLONG llLeft = 0;
+    DWORD64 qwLeft = 0;
+    LPWSTR sczLeft = NULL;
+    LONGLONG llRight = 0;
+    DWORD64 qwRight = 0;
+    LPWSTR sczRight = NULL;
+
+    // get values to compare based on type
+    if (BURN_VARIANT_TYPE_STRING == leftOperand.Type && BURN_VARIANT_TYPE_STRING == rightOperand.Type)
+    {
+        hr = BVariantGetString(&leftOperand, &sczLeft);
+        ExitOnFailure(hr, "Failed to get the left string");
+        hr = BVariantGetString(&rightOperand, &sczRight);
+        ExitOnFailure(hr, "Failed to get the right string");
+        hr = CompareStringValues(comparison, sczLeft, sczRight, pfResult);
+    }
+    else if (BURN_VARIANT_TYPE_NUMERIC == leftOperand.Type && BURN_VARIANT_TYPE_NUMERIC == rightOperand.Type)
+    {
+        hr = BVariantGetNumeric(&leftOperand, &llLeft);
+        ExitOnFailure(hr, "Failed to get the left numeric");
+        hr = BVariantGetNumeric(&rightOperand, &llRight);
+        ExitOnFailure(hr, "Failed to get the right numeric");
+        hr = CompareIntegerValues(comparison, llLeft, llRight, pfResult);
+    }
+    else if (BURN_VARIANT_TYPE_VERSION == leftOperand.Type && BURN_VARIANT_TYPE_VERSION == rightOperand.Type)
+    {
+        hr = BVariantGetVersion(&leftOperand, &qwLeft);
+        ExitOnFailure(hr, "Failed to get the left version");
+        hr = BVariantGetVersion(&rightOperand, &qwRight);
+        ExitOnFailure(hr, "Failed to get the right version");
+        hr = CompareVersionValues(comparison, qwLeft, qwRight, pfResult);
+    }
+    else if (BURN_VARIANT_TYPE_VERSION == leftOperand.Type && BURN_VARIANT_TYPE_STRING == rightOperand.Type)
+    {
+        hr = BVariantGetVersion(&leftOperand, &qwLeft);
+        ExitOnFailure(hr, "Failed to get the left version");
+        hr = BVariantGetVersion(&rightOperand, &qwRight);
+        if (FAILED(hr))
+        {
+            if (DISP_E_TYPEMISMATCH != hr)
+            {
+                ExitOnFailure(hr, "Failed to get the right version");
+            }
+            *pfResult = (BURN_SYMBOL_TYPE_NE == comparison);
+            hr = S_OK;
+        }
+        else
+        {
+            hr = CompareVersionValues(comparison, qwLeft, qwRight, pfResult);
+        }
+    }
+    else if (BURN_VARIANT_TYPE_STRING == leftOperand.Type && BURN_VARIANT_TYPE_VERSION == rightOperand.Type)
+    {
+        hr = BVariantGetVersion(&rightOperand, &qwRight);
+        ExitOnFailure(hr, "Failed to get the right version");
+        hr = BVariantGetVersion(&leftOperand, &qwLeft);
+        if (FAILED(hr))
+        {
+            if (DISP_E_TYPEMISMATCH != hr)
+            {
+                ExitOnFailure(hr, "Failed to get the left version");
+            }
+            *pfResult = (BURN_SYMBOL_TYPE_NE == comparison);
+            hr = S_OK;
+        }
+        else
+        {
+            hr = CompareVersionValues(comparison, qwLeft, qwRight, pfResult);
+        }
+    }
+    else if (BURN_VARIANT_TYPE_NUMERIC == leftOperand.Type && BURN_VARIANT_TYPE_STRING == rightOperand.Type)
+    {
+        hr = BVariantGetNumeric(&leftOperand, &llLeft);
+        ExitOnFailure(hr, "Failed to get the left numeric");
+        hr = BVariantGetNumeric(&rightOperand, &llRight);
+        if (FAILED(hr))
+        {
+            if (DISP_E_TYPEMISMATCH != hr)
+            {
+                ExitOnFailure(hr, "Failed to get the right numeric");
+            }
+            *pfResult = (BURN_SYMBOL_TYPE_NE == comparison);
+            hr = S_OK;
+        }
+        else
+        {
+            hr = CompareIntegerValues(comparison, llLeft, llRight, pfResult);
+        }
+    }
+    else if (BURN_VARIANT_TYPE_STRING == leftOperand.Type && BURN_VARIANT_TYPE_NUMERIC == rightOperand.Type)
+    {
+        hr = BVariantGetNumeric(&rightOperand, &llRight);
+        ExitOnFailure(hr, "Failed to get the right numeric");
+        hr = BVariantGetNumeric(&leftOperand, &llLeft);
+        if (FAILED(hr))
+        {
+            if (DISP_E_TYPEMISMATCH != hr)
+            {
+                ExitOnFailure(hr, "Failed to get the left numeric");
+            }
+            *pfResult = (BURN_SYMBOL_TYPE_NE == comparison);
+            hr = S_OK;
+        }
+        else
+        {
+            hr = CompareIntegerValues(comparison, llLeft, llRight, pfResult);
+        }
+    }
+    else
+    {
+        // not a combination that can be compared
+        *pfResult = (BURN_SYMBOL_TYPE_NE == comparison);
+    }
+
+LExit:
+    SecureZeroMemory(&qwLeft, sizeof(DWORD64));
+    SecureZeroMemory(&llLeft, sizeof(LONGLONG));
+    StrSecureZeroFreeString(sczLeft);
+    SecureZeroMemory(&qwRight, sizeof(DWORD64));
+    SecureZeroMemory(&llRight, sizeof(LONGLONG));
+    StrSecureZeroFreeString(sczRight);
+
+    return hr;
+}
+
+//
+// CompareStringValues - compares two string values using a given comparison.
+//
+static HRESULT CompareStringValues(
+    __in BURN_SYMBOL_TYPE comparison,
+    __in_z LPCWSTR wzLeftOperand,
+    __in_z LPCWSTR wzRightOperand,
+    __out BOOL* pfResult
+    )
+{
+    HRESULT hr = S_OK;
+    DWORD dwCompareString = (comparison & INSENSITIVE) ? NORM_IGNORECASE : 0;
+    int cchLeft = lstrlenW(wzLeftOperand);
+    int cchRight = lstrlenW(wzRightOperand);
+
+    switch (comparison)
+    {
+    case BURN_SYMBOL_TYPE_LT:
+    case BURN_SYMBOL_TYPE_GT:
+    case BURN_SYMBOL_TYPE_LE:
+    case BURN_SYMBOL_TYPE_GE:
+    case BURN_SYMBOL_TYPE_EQ:
+    case BURN_SYMBOL_TYPE_NE:
+    case BURN_SYMBOL_TYPE_LT_I:
+    case BURN_SYMBOL_TYPE_GT_I:
+    case BURN_SYMBOL_TYPE_LE_I:
+    case BURN_SYMBOL_TYPE_GE_I:
+    case BURN_SYMBOL_TYPE_EQ_I:
+    case BURN_SYMBOL_TYPE_NE_I:
+        {
+            int i = ::CompareStringW(LOCALE_INVARIANT, dwCompareString, wzLeftOperand, cchLeft, wzRightOperand, cchRight);
+            hr = CompareIntegerValues(comparison, i, CSTR_EQUAL, pfResult);
+        }
+        break;
+    case BURN_SYMBOL_TYPE_BAND:
+    case BURN_SYMBOL_TYPE_BAND_I:
+        // test if left string contains right string
+        for (int i = 0; (i + cchRight) <= cchLeft; ++i)
+        {
+            if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, dwCompareString, wzLeftOperand + i, cchRight, wzRightOperand, cchRight))
+            {
+                *pfResult = TRUE;
+                ExitFunction();
+            }
+        }
+        *pfResult = FALSE;
+        break;
+    case BURN_SYMBOL_TYPE_HIEQ:
+    case BURN_SYMBOL_TYPE_HIEQ_I:
+        // test if left string starts with right string
+        *pfResult = cchLeft >= cchRight && CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, dwCompareString, wzLeftOperand, cchRight, wzRightOperand, cchRight);
+        break;
+    case BURN_SYMBOL_TYPE_LOEQ:
+    case BURN_SYMBOL_TYPE_LOEQ_I:
+        // test if left string ends with right string
+        *pfResult = cchLeft >= cchRight && CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, dwCompareString, wzLeftOperand + (cchLeft - cchRight), cchRight, wzRightOperand, cchRight);
+        break;
+    default:
+        ExitFunction1(hr = E_INVALIDARG);
+    }
+
+LExit:
+    return hr;
+}
+
+//
+// CompareIntegerValues - compares two integer values using a given comparison.
+//
+static HRESULT CompareIntegerValues(
+    __in BURN_SYMBOL_TYPE comparison,
+    __in LONGLONG llLeftOperand,
+    __in LONGLONG llRightOperand,
+    __out BOOL* pfResult
+    )
+{
+    HRESULT hr = S_OK;
+
+    switch (comparison)
+    {
+    case BURN_SYMBOL_TYPE_LT: case BURN_SYMBOL_TYPE_LT_I: *pfResult = llLeftOperand <  llRightOperand; break;
+    case BURN_SYMBOL_TYPE_GT: case BURN_SYMBOL_TYPE_GT_I: *pfResult = llLeftOperand >  llRightOperand; break;
+    case BURN_SYMBOL_TYPE_LE: case BURN_SYMBOL_TYPE_LE_I: *pfResult = llLeftOperand <= llRightOperand; break;
+    case BURN_SYMBOL_TYPE_GE: case BURN_SYMBOL_TYPE_GE_I: *pfResult = llLeftOperand >= llRightOperand; break;
+    case BURN_SYMBOL_TYPE_EQ: case BURN_SYMBOL_TYPE_EQ_I: *pfResult = llLeftOperand == llRightOperand; break;
+    case BURN_SYMBOL_TYPE_NE: case BURN_SYMBOL_TYPE_NE_I: *pfResult = llLeftOperand != llRightOperand; break;
+    case BURN_SYMBOL_TYPE_BAND: case BURN_SYMBOL_TYPE_BAND_I: *pfResult = (llLeftOperand & llRightOperand) ? TRUE : FALSE; break;
+    case BURN_SYMBOL_TYPE_HIEQ: case BURN_SYMBOL_TYPE_HIEQ_I: *pfResult = ((llLeftOperand >> 16) & 0xFFFF) == llRightOperand; break;
+    case BURN_SYMBOL_TYPE_LOEQ: case BURN_SYMBOL_TYPE_LOEQ_I: *pfResult = (llLeftOperand & 0xFFFF) == llRightOperand; break;
+    default:
+        ExitFunction1(hr = E_INVALIDARG);
+    }
+
+LExit:
+    return hr;
+}
+
+//
+// CompareVersionValues - compares two quad-word version values using a given comparison.
+//
+static HRESULT CompareVersionValues(
+    __in BURN_SYMBOL_TYPE comparison,
+    __in DWORD64 qwLeftOperand,
+    __in DWORD64 qwRightOperand,
+    __out BOOL* pfResult
+    )
+{
+    HRESULT hr = S_OK;
+
+    switch (comparison)
+    {
+    case BURN_SYMBOL_TYPE_LT: *pfResult = qwLeftOperand <  qwRightOperand; break;
+    case BURN_SYMBOL_TYPE_GT: *pfResult = qwLeftOperand >  qwRightOperand; break;
+    case BURN_SYMBOL_TYPE_LE: *pfResult = qwLeftOperand <= qwRightOperand; break;
+    case BURN_SYMBOL_TYPE_GE: *pfResult = qwLeftOperand >= qwRightOperand; break;
+    case BURN_SYMBOL_TYPE_EQ: *pfResult = qwLeftOperand == qwRightOperand; break;
+    case BURN_SYMBOL_TYPE_NE: *pfResult = qwLeftOperand != qwRightOperand; break;
+    case BURN_SYMBOL_TYPE_BAND: *pfResult = (qwLeftOperand & qwRightOperand) ? TRUE : FALSE; break;
+    case BURN_SYMBOL_TYPE_HIEQ: *pfResult = ((qwLeftOperand >> 16) & 0xFFFF) == qwRightOperand; break;
+    case BURN_SYMBOL_TYPE_LOEQ: *pfResult = (qwLeftOperand & 0xFFFF) == qwRightOperand; break;
+    default:
+        ExitFunction1(hr = E_INVALIDARG);
+    }
+
+LExit:
+    return hr;
+}
diff --git a/src/engine/condition.h b/src/engine/condition.h
new file mode 100644
index 00000000..91627f3c
--- /dev/null
+++ b/src/engine/condition.h
@@ -0,0 +1,39 @@
+#pragma once
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+
+typedef struct _BURN_CONDITION
+{
+    // The is an expression a condition string to fire the built-in "need newer OS" message
+    LPWSTR sczConditionString;
+} BURN_CONDITION;
+
+
+// function declarations
+
+HRESULT ConditionEvaluate(
+    __in BURN_VARIABLES* pVariables,
+    __in_z LPCWSTR wzCondition,
+    __out BOOL* pf
+    );
+HRESULT ConditionGlobalCheck(
+    __in BURN_VARIABLES* pVariables,
+    __in BURN_CONDITION* pBlock,
+    __in BOOTSTRAPPER_DISPLAY display,
+    __in_z LPCWSTR wzBundleName,
+    __out DWORD *pdwExitCode,
+    __out BOOL *pfContinueExecution
+    );
+HRESULT ConditionGlobalParseFromXml(
+    __in BURN_CONDITION* pBlock,
+    __in IXMLDOMNode* pixnBundle
+    );
+
+#if defined(__cplusplus)
+}
+#endif
diff --git a/src/engine/container.cpp b/src/engine/container.cpp
new file mode 100644
index 00000000..ada9025b
--- /dev/null
+++ b/src/engine/container.cpp
@@ -0,0 +1,386 @@
+// 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.
+
+#include "precomp.h"
+
+
+// internal function declarations
+
+static HRESULT GetAttachedContainerInfo(
+    __in HANDLE hFile,
+    __in DWORD iContainerIndex,
+    __out DWORD* pdwFormat,
+    __out DWORD64* pqwOffset,
+    __out DWORD64* pqwSize
+    );
+
+
+// function definitions
+
+extern "C" HRESULT ContainersParseFromXml(
+    __in BURN_SECTION* pSection,
+    __in BURN_CONTAINERS* pContainers,
+    __in IXMLDOMNode* pixnBundle
+    )
+{
+    HRESULT hr = S_OK;
+    IXMLDOMNodeList* pixnNodes = NULL;
+    IXMLDOMNode* pixnNode = NULL;
+    DWORD cNodes = 0;
+    LPWSTR scz = NULL;
+
+    // select container nodes
+    hr = XmlSelectNodes(pixnBundle, L"Container", &pixnNodes);
+    ExitOnFailure(hr, "Failed to select container nodes.");
+
+    // get container node count
+    hr = pixnNodes->get_length((long*)&cNodes);
+    ExitOnFailure(hr, "Failed to get container node count.");
+
+    if (!cNodes)
+    {
+        ExitFunction();
+    }
+
+    // allocate memory for searches
+    pContainers->rgContainers = (BURN_CONTAINER*)MemAlloc(sizeof(BURN_CONTAINER) * cNodes, TRUE);
+    ExitOnNull(pContainers->rgContainers, hr, E_OUTOFMEMORY, "Failed to allocate memory for container structs.");
+
+    pContainers->cContainers = cNodes;
+
+    // parse search elements
+    for (DWORD i = 0; i < cNodes; ++i)
+    {
+        BURN_CONTAINER* pContainer = &pContainers->rgContainers[i];
+
+        hr = XmlNextElement(pixnNodes, &pixnNode, NULL);
+        ExitOnFailure(hr, "Failed to get next node.");
+
+        // TODO: Read type from manifest. Today only CABINET is supported.
+        pContainer->type = BURN_CONTAINER_TYPE_CABINET;
+
+        // @Id
+        hr = XmlGetAttributeEx(pixnNode, L"Id", &pContainer->sczId);
+        ExitOnFailure(hr, "Failed to get @Id.");
+
+        // @Primary
+        hr = XmlGetYesNoAttribute(pixnNode, L"Primary", &pContainer->fPrimary);
+        if (E_NOTFOUND != hr)
+        {
+            ExitOnFailure(hr, "Failed to get @Primary.");
+        }
+
+        // @Attached
+        hr = XmlGetYesNoAttribute(pixnNode, L"Attached", &pContainer->fAttached);
+        if (E_NOTFOUND != hr || pContainer->fPrimary) // if it is a primary container, it has to be attached
+        {
+            ExitOnFailure(hr, "Failed to get @Attached.");
+        }
+
+        // @AttachedIndex
+        hr = XmlGetAttributeNumber(pixnNode, L"AttachedIndex", &pContainer->dwAttachedIndex);
+        if (E_NOTFOUND != hr || pContainer->fAttached) // if it is an attached container it must have an index
+        {
+            ExitOnFailure(hr, "Failed to get @AttachedIndex.");
+        }
+
+        // Attached containers are always found attached to the current process, so use the current proccess's
+        // name instead of what may be in the manifest.
+        if (pContainer->fAttached)
+        {
+            hr = PathForCurrentProcess(&scz, NULL);
+            ExitOnFailure(hr, "Failed to get path to current process for attached container.");
+
+            LPCWSTR wzFileName = PathFile(scz);
+
+            hr = StrAllocString(&pContainer->sczFilePath, wzFileName, 0);
+            ExitOnFailure(hr, "Failed to set attached container file path.");
+        }
+        else
+        {
+            // @FilePath
+            hr = XmlGetAttributeEx(pixnNode, L"FilePath", &pContainer->sczFilePath);
+            if (E_NOTFOUND != hr)
+            {
+                ExitOnFailure(hr, "Failed to get @FilePath.");
+            }
+        }
+
+        // The source path starts as the file path.
+        hr = StrAllocString(&pContainer->sczSourcePath, pContainer->sczFilePath, 0);
+        ExitOnFailure(hr, "Failed to copy @FilePath");
+
+        // @DownloadUrl
+        hr = XmlGetAttributeEx(pixnNode, L"DownloadUrl", &pContainer->downloadSource.sczUrl);
+        if (E_NOTFOUND != hr || (!pContainer->fPrimary && !pContainer->sczSourcePath)) // if the package is not a primary package, it must have a source path or a download url
+        {
+            ExitOnFailure(hr, "Failed to get @DownloadUrl. Either @SourcePath or @DownloadUrl needs to be provided.");
+        }
+
+        // @Hash
+        hr = XmlGetAttributeEx(pixnNode, L"Hash", &pContainer->sczHash);
+        if (SUCCEEDED(hr))
+        {
+            hr = StrAllocHexDecode(pContainer->sczHash, &pContainer->pbHash, &pContainer->cbHash);
+            ExitOnFailure(hr, "Failed to hex decode the Container/@Hash.");
+        }
+        else if (E_NOTFOUND != hr)
+        {
+            ExitOnFailure(hr, "Failed to get @Hash.");
+        }
+
+        // If the container is attached, make sure the information in the section matches what the
+        // manifest contained and get the offset to the container.
+        if (pContainer->fAttached)
+        {
+            hr = SectionGetAttachedContainerInfo(pSection, pContainer->dwAttachedIndex, pContainer->type, &pContainer->qwAttachedOffset, &pContainer->qwFileSize, &pContainer->fActuallyAttached);
+            ExitOnFailure(hr, "Failed to get attached container information.");
+        }
+
+        // prepare next iteration
+        ReleaseNullObject(pixnNode);
+    }
+
+    hr = S_OK;
+
+LExit:
+    ReleaseObject(pixnNodes);
+    ReleaseObject(pixnNode);
+    ReleaseStr(scz);
+
+    return hr;
+}
+
+extern "C" void ContainersUninitialize(
+    __in BURN_CONTAINERS* pContainers
+    )
+{
+    if (pContainers->rgContainers)
+    {
+        for (DWORD i = 0; i < pContainers->cContainers; ++i)
+        {
+            BURN_CONTAINER* pContainer = &pContainers->rgContainers[i];
+
+            ReleaseStr(pContainer->sczId);
+            ReleaseStr(pContainer->sczHash);
+            ReleaseStr(pContainer->sczSourcePath);
+            ReleaseStr(pContainer->sczFilePath);
+            ReleaseMem(pContainer->pbHash);
+            ReleaseStr(pContainer->downloadSource.sczUrl);
+            ReleaseStr(pContainer->downloadSource.sczUser);
+            ReleaseStr(pContainer->downloadSource.sczPassword);
+        }
+        MemFree(pContainers->rgContainers);
+    }
+
+    // clear struct
+    memset(pContainers, 0, sizeof(BURN_CONTAINERS));
+}
+
+extern "C" HRESULT ContainerOpenUX(
+    __in BURN_SECTION* pSection,
+    __in BURN_CONTAINER_CONTEXT* pContext
+    )
+{
+    HRESULT hr = S_OK;
+    BURN_CONTAINER container = { };
+    LPWSTR sczExecutablePath = NULL;
+
+    // open attached container
+    container.type = BURN_CONTAINER_TYPE_CABINET;
+    container.fPrimary = TRUE;
+    container.fAttached = TRUE;
+    container.dwAttachedIndex = 0;
+
+    hr = SectionGetAttachedContainerInfo(pSection, container.dwAttachedIndex, container.type, &container.qwAttachedOffset, &container.qwFileSize, &container.fActuallyAttached);
+    ExitOnFailure(hr, "Failed to get container information for UX container.");
+
+    AssertSz(container.fActuallyAttached, "The BA container must always be found attached.");
+
+    hr = PathForCurrentProcess(&sczExecutablePath, NULL);
+    ExitOnFailure(hr, "Failed to get path for executing module.");
+
+    hr = ContainerOpen(pContext, &container, pSection->hEngineFile, sczExecutablePath);
+    ExitOnFailure(hr, "Failed to open attached container.");
+
+LExit:
+    ReleaseStr(sczExecutablePath);
+
+    return hr;
+}
+
+extern "C" HRESULT ContainerOpen(
+    __in BURN_CONTAINER_CONTEXT* pContext,
+    __in BURN_CONTAINER* pContainer,
+    __in HANDLE hContainerFile,
+    __in_z LPCWSTR wzFilePath
+    )
+{
+    HRESULT hr = S_OK;
+    LARGE_INTEGER li = { };
+
+    // initialize context
+    pContext->type = pContainer->type;
+    pContext->qwSize = pContainer->qwFileSize;
+    pContext->qwOffset = pContainer->qwAttachedOffset;
+
+    // If the handle to the container is not open already, open container file
+    if (INVALID_HANDLE_VALUE == hContainerFile)
+    {
+        pContext->hFile = ::CreateFileW(wzFilePath, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN, NULL);
+        ExitOnInvalidHandleWithLastError(pContext->hFile, hr, "Failed to open file: %ls", wzFilePath);
+    }
+    else // use the container file handle.
+    {
+        if (!::DuplicateHandle(::GetCurrentProcess(), hContainerFile, ::GetCurrentProcess(), &pContext->hFile, 0, FALSE, DUPLICATE_SAME_ACCESS))
+        {
+            ExitWithLastError(hr, "Failed to duplicate handle to container: %ls", wzFilePath);
+        }
+    }
+
+    // If it is a container attached to an executable, seek to the container offset.
+    if (pContainer->fAttached)
+    {
+        li.QuadPart = (LONGLONG)pContext->qwOffset;
+    }
+
+    if (!::SetFilePointerEx(pContext->hFile, li, NULL, FILE_BEGIN))
+    {
+        ExitWithLastError(hr, "Failed to move file pointer to container offset.");
+    }
+
+    // open the archive
+    switch (pContext->type)
+    {
+    case BURN_CONTAINER_TYPE_CABINET:
+        hr = CabExtractOpen(pContext, wzFilePath);
+        break;
+    }
+    ExitOnFailure(hr, "Failed to open container.");
+
+LExit:
+    return hr;
+}
+
+extern "C" HRESULT ContainerNextStream(
+    __in BURN_CONTAINER_CONTEXT* pContext,
+    __inout_z LPWSTR* psczStreamName
+    )
+{
+    HRESULT hr = S_OK;
+
+    switch (pContext->type)
+    {
+    case BURN_CONTAINER_TYPE_CABINET:
+        hr = CabExtractNextStream(pContext, psczStreamName);
+        break;
+    }
+
+//LExit:
+    return hr;
+}
+
+extern "C" HRESULT ContainerStreamToFile(
+    __in BURN_CONTAINER_CONTEXT* pContext,
+    __in_z LPCWSTR wzFileName
+    )
+{
+    HRESULT hr = S_OK;
+
+    switch (pContext->type)
+    {
+    case BURN_CONTAINER_TYPE_CABINET:
+        hr = CabExtractStreamToFile(pContext, wzFileName);
+        break;
+    }
+
+//LExit:
+    return hr;
+}
+
+extern "C" HRESULT ContainerStreamToBuffer(
+    __in BURN_CONTAINER_CONTEXT* pContext,
+    __out BYTE** ppbBuffer,
+    __out SIZE_T* pcbBuffer
+    )
+{
+    HRESULT hr = S_OK;
+
+    switch (pContext->type)
+    {
+    case BURN_CONTAINER_TYPE_CABINET:
+        hr = CabExtractStreamToBuffer(pContext, ppbBuffer, pcbBuffer);
+        break;
+    }
+
+//LExit:
+    return hr;
+}
+
+extern "C" HRESULT ContainerSkipStream(
+    __in BURN_CONTAINER_CONTEXT* pContext
+    )
+{
+    HRESULT hr = S_OK;
+
+    switch (pContext->type)
+    {
+    case BURN_CONTAINER_TYPE_CABINET:
+        hr = CabExtractSkipStream(pContext);
+        break;
+    }
+
+//LExit:
+    return hr;
+}
+
+extern "C" HRESULT ContainerClose(
+    __in BURN_CONTAINER_CONTEXT* pContext
+    )
+{
+    HRESULT hr = S_OK;
+
+    // close container
+    switch (pContext->type)
+    {
+    case BURN_CONTAINER_TYPE_CABINET:
+        hr = CabExtractClose(pContext);
+        ExitOnFailure(hr, "Failed to close cabinet.");
+        break;
+    }
+
+LExit:
+    ReleaseFile(pContext->hFile);
+
+    if (SUCCEEDED(hr))
+    {
+        memset(pContext, 0, sizeof(BURN_CONTAINER_CONTEXT));
+    }
+
+    return hr;
+}
+
+extern "C" HRESULT ContainerFindById(
+    __in BURN_CONTAINERS* pContainers,
+    __in_z LPCWSTR wzId,
+    __out BURN_CONTAINER** ppContainer
+    )
+{
+    HRESULT hr = S_OK;
+    BURN_CONTAINER* pContainer = NULL;
+
+    for (DWORD i = 0; i < pContainers->cContainers; ++i)
+    {
+        pContainer = &pContainers->rgContainers[i];
+
+        if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, pContainer->sczId, -1, wzId, -1))
+        {
+            *ppContainer = pContainer;
+            ExitFunction1(hr = S_OK);
+        }
+    }
+
+    hr = E_NOTFOUND;
+
+LExit:
+    return hr;
+}
diff --git a/src/engine/container.h b/src/engine/container.h
new file mode 100644
index 00000000..2ca3d7ad
--- /dev/null
+++ b/src/engine/container.h
@@ -0,0 +1,183 @@
+#pragma once
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+
+// typedefs
+
+//typedef HRESULT (*PFN_EXTRACTOPEN)(
+//    __in HANDLE hFile,
+//    __in DWORD64 qwOffset,
+//    __in DWORD64 qwSize,
+//    __out void** ppCookie
+//    );
+//typedef HRESULT (*PFN_EXTRACTNEXTSTREAM)(
+//    __in void* pCookie,
+//    __inout_z LPWSTR* psczStreamName
+//    );
+//typedef HRESULT (*PFN_EXTRACTSTREAMTOFILE)(
+//    __in void* pCookie,
+//    __in_z LPCWSTR wzFileName
+//    );
+//typedef HRESULT (*PFN_EXTRACTSTREAMTOBUFFER)(
+//    __in void* pCookie,
+//    __out BYTE** ppbBuffer,
+//    __out SIZE_T* pcbBuffer
+//    );
+//typedef HRESULT (*PFN_EXTRACTCLOSE)(
+//    __in void* pCookie
+//    );
+
+
+// constants
+
+enum BURN_CONTAINER_TYPE
+{
+    BURN_CONTAINER_TYPE_NONE,
+    BURN_CONTAINER_TYPE_CABINET,
+    BURN_CONTAINER_TYPE_SEVENZIP,
+};
+
+enum BURN_CAB_OPERATION
+{
+    BURN_CAB_OPERATION_NONE,
+    BURN_CAB_OPERATION_NEXT_STREAM,
+    BURN_CAB_OPERATION_STREAM_TO_FILE,
+    BURN_CAB_OPERATION_STREAM_TO_BUFFER,
+    BURN_CAB_OPERATION_SKIP_STREAM,
+    BURN_CAB_OPERATION_CLOSE,
+};
+
+
+// structs
+
+typedef struct _BURN_CONTAINER
+{
+    LPWSTR sczId;
+    BURN_CONTAINER_TYPE type;
+    BOOL fPrimary;
+    BOOL fAttached;
+    DWORD dwAttachedIndex;
+    DWORD64 qwFileSize;
+    LPWSTR sczHash;
+    LPWSTR sczFilePath;         // relative path to container.
+    LPWSTR sczSourcePath;
+    DOWNLOAD_SOURCE downloadSource;
+
+    BYTE* pbHash;
+    DWORD cbHash;
+    DWORD64 qwAttachedOffset;
+    BOOL fActuallyAttached;     // indicates whether an attached container is attached or missing.
+
+    //LPWSTR* rgsczPayloads;
+    //DWORD cPayloads;
+} BURN_CONTAINER;
+
+typedef struct _BURN_CONTAINERS
+{
+    BURN_CONTAINER* rgContainers;
+    DWORD cContainers;
+} BURN_CONTAINERS;
+
+typedef struct _BURN_CONTAINER_CONTEXT_CABINET_VIRTUAL_FILE_POINTER
+{
+    HANDLE hFile;
+    LARGE_INTEGER liPosition;
+} BURN_CONTAINER_CONTEXT_CABINET_VIRTUAL_FILE_POINTER;
+
+typedef struct _BURN_CONTAINER_CONTEXT_CABINET
+{
+    LPWSTR sczFile;
+
+    HANDLE hThread;
+    HANDLE hBeginOperationEvent;
+    HANDLE hOperationCompleteEvent;
+
+    BURN_CAB_OPERATION operation;
+    HRESULT hrError;
+
+    LPWSTR* psczStreamName;
+    LPCWSTR wzTargetFile;
+    HANDLE hTargetFile;
+    BYTE* pbTargetBuffer;
+    DWORD cbTargetBuffer;
+    DWORD iTargetBuffer;
+
+    BURN_CONTAINER_CONTEXT_CABINET_VIRTUAL_FILE_POINTER* rgVirtualFilePointers;
+    DWORD cVirtualFilePointers;
+} BURN_CONTAINER_CONTEXT_CABINET;
+
+typedef struct _BURN_CONTAINER_CONTEXT
+{
+    HANDLE hFile;
+    DWORD64 qwOffset;
+    DWORD64 qwSize;
+
+    //PFN_EXTRACTOPEN pfnExtractOpen;
+    //PFN_EXTRACTNEXTSTREAM pfnExtractNextStream;
+    //PFN_EXTRACTSTREAMTOFILE pfnExtractStreamToFile;
+    //PFN_EXTRACTSTREAMTOBUFFER pfnExtractStreamToBuffer;
+    //PFN_EXTRACTCLOSE pfnExtractClose;
+    //void* pCookie;
+    BURN_CONTAINER_TYPE type;
+    union
+    {
+        BURN_CONTAINER_CONTEXT_CABINET Cabinet;
+    };
+
+} BURN_CONTAINER_CONTEXT;
+
+
+// functions
+
+HRESULT ContainersParseFromXml(
+    __in BURN_SECTION* pSection,
+    __in BURN_CONTAINERS* pContainers,
+    __in IXMLDOMNode* pixnBundle
+    );
+void ContainersUninitialize(
+    __in BURN_CONTAINERS* pContainers
+    );
+HRESULT ContainerOpenUX(
+    __in BURN_SECTION* pSection,
+    __in BURN_CONTAINER_CONTEXT* pContext
+    );
+HRESULT ContainerOpen(
+    __in BURN_CONTAINER_CONTEXT* pContext,
+    __in BURN_CONTAINER* pContainer,
+    __in HANDLE hContainerFile,
+    __in_z LPCWSTR wzFilePath
+    );
+HRESULT ContainerNextStream(
+    __inout BURN_CONTAINER_CONTEXT* pContext,
+    __inout_z LPWSTR* psczStreamName
+    );
+HRESULT ContainerStreamToFile(
+    __in BURN_CONTAINER_CONTEXT* pContext,
+    __in_z LPCWSTR wzFileName
+    );
+HRESULT ContainerStreamToBuffer(
+    __in BURN_CONTAINER_CONTEXT* pContext,
+    __out BYTE** ppbBuffer,
+    __out SIZE_T* pcbBuffer
+    );
+HRESULT ContainerSkipStream(
+    __in BURN_CONTAINER_CONTEXT* pContext
+    );
+HRESULT ContainerClose(
+    __in BURN_CONTAINER_CONTEXT* pContext
+    );
+HRESULT ContainerFindById(
+    __in BURN_CONTAINERS* pContainers,
+    __in_z LPCWSTR wzId,
+    __out BURN_CONTAINER** ppContainer
+    );
+
+
+#if defined(__cplusplus)
+}
+#endif
diff --git a/src/engine/core.cpp b/src/engine/core.cpp
new file mode 100644
index 00000000..519012e9
--- /dev/null
+++ b/src/engine/core.cpp
@@ -0,0 +1,1705 @@
+// 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.
+
+#include "precomp.h"
+
+
+// structs
+
+struct BURN_CACHE_THREAD_CONTEXT
+{
+    BURN_ENGINE_STATE* pEngineState;
+    DWORD* pcOverallProgressTicks;
+    BOOL* pfRollback;
+};
+
+
+// internal function declarations
+
+static HRESULT ParseCommandLine(
+    __in int argc,
+    __in LPWSTR* argv,
+    __in BOOTSTRAPPER_COMMAND* pCommand,
+    __in BURN_PIPE_CONNECTION* pCompanionConnection,
+    __in BURN_PIPE_CONNECTION* pEmbeddedConnection,
+    __in BURN_VARIABLES* pVariables,
+    __out BURN_MODE* pMode,
+    __out BURN_AU_PAUSE_ACTION* pAutomaticUpdates,
+    __out BOOL* pfDisableSystemRestore,
+    __out_z LPWSTR* psczSourceProcessPath,
+    __out_z LPWSTR* psczOriginalSource,
+    __out BOOL* pfDisableUnelevate,
+    __out DWORD *pdwLoggingAttributes,
+    __out_z LPWSTR* psczLogFile,
+    __out_z LPWSTR* psczActiveParent,
+    __out_z LPWSTR* psczIgnoreDependencies,
+    __out_z LPWSTR* psczAncestors,
+    __out_z LPWSTR* psczSanitizedCommandLine
+    );
+static HRESULT ParsePipeConnection(
+    __in LPWSTR* rgArgs,
+    __in BURN_PIPE_CONNECTION* pConnection
+    );
+static HRESULT DetectPackage(
+    __in BURN_ENGINE_STATE* pEngineState,
+    __in BURN_PACKAGE* pPackage
+    );
+static HRESULT DetectPackagePayloadsCached(
+    __in BURN_PACKAGE* pPackage
+    );
+static DWORD WINAPI CacheThreadProc(
+    __in LPVOID lpThreadParameter
+    );
+static HRESULT WaitForCacheThread(
+    __in HANDLE hCacheThread
+    );
+static void LogPackages(
+    __in_opt const BURN_PACKAGE* pUpgradeBundlePackage,
+    __in_opt const BURN_PACKAGE* pForwardCompatibleBundlePackage,
+    __in const BURN_PACKAGES* pPackages,
+    __in const BURN_RELATED_BUNDLES* pRelatedBundles,
+    __in const BOOTSTRAPPER_ACTION action
+    );
+
+
+// function definitions
+
+extern "C" HRESULT CoreInitialize(
+    __in BURN_ENGINE_STATE* pEngineState
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR sczSanitizedCommandLine = NULL;
+    LPWSTR sczStreamName = NULL;
+    BYTE* pbBuffer = NULL;
+    SIZE_T cbBuffer = 0;
+    BURN_CONTAINER_CONTEXT containerContext = { };
+    BOOL fElevated = FALSE;
+    LPWSTR sczSourceProcessPath = NULL;
+    LPWSTR sczSourceProcessFolder = NULL;
+    LPWSTR sczOriginalSource = NULL;
+
+    // Initialize variables.
+    hr = VariableInitialize(&pEngineState->variables);
+    ExitOnFailure(hr, "Failed to initialize variables.");
+
+    // Open attached UX container.
+    hr = ContainerOpenUX(&pEngineState->section, &containerContext);
+    ExitOnFailure(hr, "Failed to open attached UX container.");
+
+    // Load manifest.
+    hr = ContainerNextStream(&containerContext, &sczStreamName);
+    ExitOnFailure(hr, "Failed to open manifest stream.");
+
+    hr = ContainerStreamToBuffer(&containerContext, &pbBuffer, &cbBuffer);
+    ExitOnFailure(hr, "Failed to get manifest stream from container.");
+
+    hr = ManifestLoadXmlFromBuffer(pbBuffer, cbBuffer, pEngineState);
+    ExitOnFailure(hr, "Failed to load manifest.");
+
+    // Parse command line.
+    hr = ParseCommandLine(pEngineState->argc, pEngineState->argv, &pEngineState->command, &pEngineState->companionConnection, &pEngineState->embeddedConnection, &pEngineState->variables, &pEngineState->mode, &pEngineState->automaticUpdates, &pEngineState->fDisableSystemRestore, &sczSourceProcessPath, &sczOriginalSource, &pEngineState->fDisableUnelevate, &pEngineState->log.dwAttributes, &pEngineState->log.sczPath, &pEngineState->registration.sczActiveParent, &pEngineState->sczIgnoreDependencies, &pEngineState->registration.sczAncestors, &sczSanitizedCommandLine);
+    ExitOnFailure(hr, "Failed to parse command line.");
+
+    LogId(REPORT_STANDARD, MSG_BURN_COMMAND_LINE, sczSanitizedCommandLine ? sczSanitizedCommandLine : L"");
+
+    // Retain whether bundle was initially run elevated.
+    ProcElevated(::GetCurrentProcess(), &fElevated);
+
+    hr = VariableSetNumeric(&pEngineState->variables, BURN_BUNDLE_ELEVATED, fElevated, TRUE);
+    ExitOnFailure(hr, "Failed to overwrite the %ls built-in variable.", BURN_BUNDLE_ELEVATED);
+
+    hr = VariableSetNumeric(&pEngineState->variables, BURN_BUNDLE_UILEVEL, pEngineState->command.display, TRUE);
+    ExitOnFailure(hr, "Failed to overwrite the %ls built-in variable.", BURN_BUNDLE_UILEVEL);
+
+    if (sczSourceProcessPath)
+    {
+        hr = VariableSetLiteralString(&pEngineState->variables, BURN_BUNDLE_SOURCE_PROCESS_PATH, sczSourceProcessPath, TRUE);
+        ExitOnFailure(hr, "Failed to set source process path variable.");
+
+        hr = PathGetDirectory(sczSourceProcessPath, &sczSourceProcessFolder);
+        ExitOnFailure(hr, "Failed to get source process folder from path.");
+
+        hr = VariableSetLiteralString(&pEngineState->variables, BURN_BUNDLE_SOURCE_PROCESS_FOLDER, sczSourceProcessFolder, TRUE);
+        ExitOnFailure(hr, "Failed to set source process folder variable.");
+    }
+
+    // Set BURN_BUNDLE_ORIGINAL_SOURCE, if it was passed in on the command line.
+    // Needs to be done after ManifestLoadXmlFromBuffer.
+    if (sczOriginalSource)
+    {
+        hr = VariableSetLiteralString(&pEngineState->variables, BURN_BUNDLE_ORIGINAL_SOURCE, sczOriginalSource, FALSE);
+        ExitOnFailure(hr, "Failed to set original source variable.");
+    }
+
+    if (BURN_MODE_UNTRUSTED == pEngineState->mode || BURN_MODE_NORMAL == pEngineState->mode || BURN_MODE_EMBEDDED == pEngineState->mode)
+    {
+        hr = CacheInitialize(&pEngineState->registration, &pEngineState->variables, sczSourceProcessPath);
+        ExitOnFailure(hr, "Failed to initialize internal cache functionality.");
+    }
+
+    // If we're not elevated then we'll be loading the bootstrapper application, so extract
+    // the payloads from the BA container.
+    if (BURN_MODE_NORMAL == pEngineState->mode || BURN_MODE_EMBEDDED == pEngineState->mode)
+    {
+        // Extract all UX payloads to working folder.
+        hr = UserExperienceEnsureWorkingFolder(pEngineState->registration.sczId, &pEngineState->userExperience.sczTempDirectory);
+        ExitOnFailure(hr, "Failed to get unique temporary folder for bootstrapper application.");
+
+        hr = PayloadExtractFromContainer(&pEngineState->userExperience.payloads, NULL, &containerContext, pEngineState->userExperience.sczTempDirectory);
+        ExitOnFailure(hr, "Failed to extract bootstrapper application payloads.");
+
+        // Load the catalog files as soon as they are extracted.
+        hr = CatalogLoadFromPayload(&pEngineState->catalogs, &pEngineState->userExperience.payloads);
+        ExitOnFailure(hr, "Failed to load catalog files.");
+    }
+
+LExit:
+    ReleaseStr(sczOriginalSource);
+    ReleaseStr(sczSourceProcessFolder);
+    ReleaseStr(sczSourceProcessPath);
+    ContainerClose(&containerContext);
+    ReleaseStr(sczStreamName);
+    ReleaseStr(sczSanitizedCommandLine);
+    ReleaseMem(pbBuffer);
+
+    return hr;
+}
+
+extern "C" HRESULT CoreSerializeEngineState(
+    __in BURN_ENGINE_STATE* pEngineState,
+    __inout BYTE** ppbBuffer,
+    __inout SIZE_T* piBuffer
+    )
+{
+    HRESULT hr = S_OK;
+
+    hr = VariableSerialize(&pEngineState->variables, TRUE, ppbBuffer, piBuffer);
+    ExitOnFailure(hr, "Failed to serialize variables.");
+
+LExit:
+    return hr;
+}
+
+extern "C" HRESULT CoreQueryRegistration(
+    __in BURN_ENGINE_STATE* pEngineState
+    )
+{
+    HRESULT hr = S_OK;
+    BYTE* pbBuffer = NULL;
+    SIZE_T cbBuffer = 0;
+    SIZE_T iBuffer = 0;
+
+    // Detect if bundle is already installed.
+    hr = RegistrationDetectInstalled(&pEngineState->registration, &pEngineState->registration.fInstalled);
+    ExitOnFailure(hr, "Failed to detect bundle install state.");
+
+    // detect resume type
+    hr = RegistrationDetectResumeType(&pEngineState->registration, &pEngineState->command.resumeType);
+    ExitOnFailure(hr, "Failed to detect resume type.");
+
+    // If we have a resume mode that suggests the bundle might already be present, try to load any
+    // previously stored state.
+    if (BOOTSTRAPPER_RESUME_TYPE_INVALID < pEngineState->command.resumeType)
+    {
+        // load resume state
+        hr = RegistrationLoadState(&pEngineState->registration, &pbBuffer, &cbBuffer);
+        if (SUCCEEDED(hr))
+        {
+            hr = VariableDeserialize(&pEngineState->variables, TRUE, pbBuffer, cbBuffer, &iBuffer);
+        }
+
+        // Log any failures and continue.
+        if (FAILED(hr))
+        {
+            LogId(REPORT_STANDARD, MSG_CANNOT_LOAD_STATE_FILE, hr, pEngineState->registration.sczStateFile);
+            hr = S_OK;
+        }
+    }
+
+LExit:
+    ReleaseBuffer(pbBuffer);
+
+    return hr;
+}
+
+extern "C" HRESULT CoreDetect(
+    __in BURN_ENGINE_STATE* pEngineState,
+    __in_opt HWND hwndParent
+    )
+{
+    HRESULT hr = S_OK;
+    BOOL fActivated = FALSE;
+    BOOL fDetectBegan = FALSE;
+    BURN_PACKAGE* pPackage = NULL;
+    HRESULT hrFirstPackageFailure = S_OK;
+
+    LogId(REPORT_STANDARD, MSG_DETECT_BEGIN, pEngineState->packages.cPackages);
+
+    hr = UserExperienceActivateEngine(&pEngineState->userExperience, &fActivated);
+    ExitOnFailure(hr, "Engine cannot start detect because it is busy with another action.");
+
+    // Detect if bundle installed state has changed since start up. This
+    // only happens if Apply() changed the state of bundle (installed or
+    // uninstalled). In that case, Detect() can be used here to reset
+    // the installed state.
+    hr = RegistrationDetectInstalled(&pEngineState->registration, &pEngineState->registration.fInstalled);
+    ExitOnFailure(hr, "Failed to detect bundle install state.");
+
+    if (pEngineState->registration.fInstalled)
+    {
+        hr = VariableSetNumeric(&pEngineState->variables, BURN_BUNDLE_INSTALLED, 1, TRUE);
+        ExitOnFailure(hr, "Failed to set the bundle installed built-in variable.");
+    }
+    else
+    {
+        hr = VariableSetString(&pEngineState->variables, BURN_BUNDLE_INSTALLED, NULL, TRUE);
+        ExitOnFailure(hr, "Failed to unset the bundle installed built-in variable.");
+    }
+
+    fDetectBegan = TRUE;
+    hr = UserExperienceOnDetectBegin(&pEngineState->userExperience, pEngineState->registration.fInstalled, pEngineState->packages.cPackages);
+    ExitOnRootFailure(hr, "UX aborted detect begin.");
+
+    pEngineState->userExperience.hwndDetect = hwndParent;
+
+    // Always reset the detect state which means the plan should be reset too.
+    DetectReset(&pEngineState->registration, &pEngineState->packages);
+    PlanReset(&pEngineState->plan, &pEngineState->packages);
+
+    hr = SearchesExecute(&pEngineState->searches, &pEngineState->variables);
+    ExitOnFailure(hr, "Failed to execute searches.");
+
+    // Load all of the related bundles.
+    hr = RegistrationDetectRelatedBundles(&pEngineState->registration);
+    ExitOnFailure(hr, "Failed to detect related bundles.");
+
+    hr = DependencyDetectProviderKeyBundleId(&pEngineState->registration);
+    if (SUCCEEDED(hr))
+    {
+        hr = DetectForwardCompatibleBundle(&pEngineState->userExperience, &pEngineState->command, &pEngineState->registration);
+        ExitOnFailure(hr, "Failed to detect forward compatible bundle.");
+
+        // If a forward compatible bundle was detected, skip rest of bundle detection
+        // since we will passthrough.
+        if (pEngineState->registration.fEnabledForwardCompatibleBundle)
+        {
+            ExitFunction();
+        }
+    }
+    else if (E_NOTFOUND == hr)
+    {
+        hr = S_OK;
+    }
+    ExitOnFailure(hr, "Failed to detect provider key bundle id.");
+
+    // Report the related bundles.
+    hr = DetectReportRelatedBundles(&pEngineState->userExperience, &pEngineState->registration, pEngineState->command.relationType, pEngineState->command.action);
+    ExitOnFailure(hr, "Failed to report detected related bundles.");
+
+    // Do update detection.
+    hr = DetectUpdate(pEngineState->registration.sczId, &pEngineState->userExperience, &pEngineState->update);
+    ExitOnFailure(hr, "Failed to detect update.");
+
+    // Detecting MSPs requires special initialization before processing each package but
+    // only do the detection if there are actually patch packages to detect because it
+    // can be expensive.
+    if (pEngineState->packages.cPatchInfo)
+    {
+        hr = MspEngineDetectInitialize(&pEngineState->packages);
+        ExitOnFailure(hr, "Failed to initialize MSP engine detection.");
+    }
+
+    for (DWORD i = 0; i < pEngineState->packages.cPackages; ++i)
+    {
+        pPackage = pEngineState->packages.rgPackages + i;
+
+        hr = DetectPackage(pEngineState, pPackage);
+
+        // If the package detection failed, ensure the package state is set to unknown.
+        if (FAILED(hr))
+        {
+            if (SUCCEEDED(hrFirstPackageFailure))
+            {
+                hrFirstPackageFailure = hr;
+            }
+
+            pPackage->currentState = BOOTSTRAPPER_PACKAGE_STATE_UNKNOWN;
+        }
+    }
+
+    // Log the detected states.
+    for (DWORD iPackage = 0; iPackage < pEngineState->packages.cPackages; ++iPackage)
+    {
+        pPackage = pEngineState->packages.rgPackages + iPackage;
+
+        LogId(REPORT_STANDARD, MSG_DETECTED_PACKAGE, pPackage->sczId, LoggingPackageStateToString(pPackage->currentState), LoggingCacheStateToString(pPackage->cache));
+
+        if (BURN_PACKAGE_TYPE_MSI == pPackage->type)
+        {
+            for (DWORD iFeature = 0; iFeature < pPackage->Msi.cFeatures; ++iFeature)
+            {
+                const BURN_MSIFEATURE* pFeature = pPackage->Msi.rgFeatures + iFeature;
+                LogId(REPORT_STANDARD, MSG_DETECTED_MSI_FEATURE, pPackage->sczId, pFeature->sczId, LoggingMsiFeatureStateToString(pFeature->currentState));
+            }
+        }
+        else if (BURN_PACKAGE_TYPE_MSP == pPackage->type)
+        {
+            for (DWORD iTargetProduct = 0; iTargetProduct < pPackage->Msp.cTargetProductCodes; ++iTargetProduct)
+            {
+                const BURN_MSPTARGETPRODUCT* pTargetProduct = pPackage->Msp.rgTargetProducts + iTargetProduct;
+                LogId(REPORT_STANDARD, MSG_DETECTED_MSP_TARGET, pPackage->sczId, pTargetProduct->wzTargetProductCode, LoggingPackageStateToString(pTargetProduct->patchPackageState));
+            }
+        }
+    }
+
+LExit:
+    if (SUCCEEDED(hr))
+    {
+        hr = hrFirstPackageFailure;
+    }
+
+    if (fActivated)
+    {
+        UserExperienceDeactivateEngine(&pEngineState->userExperience);
+    }
+
+    if (fDetectBegan)
+    {
+        UserExperienceOnDetectComplete(&pEngineState->userExperience, hr);
+    }
+
+    pEngineState->userExperience.hwndDetect = NULL;
+
+    LogId(REPORT_STANDARD, MSG_DETECT_COMPLETE, hr);
+
+    return hr;
+}
+
+extern "C" HRESULT CorePlan(
+    __in BURN_ENGINE_STATE* pEngineState,
+    __in BOOTSTRAPPER_ACTION action
+    )
+{
+    HRESULT hr = S_OK;
+    BOOL fActivated = FALSE;
+    BOOL fPlanBegan = FALSE;
+    LPWSTR sczLayoutDirectory = NULL;
+    HANDLE hSyncpointEvent = NULL;
+    BURN_PACKAGE* pUpgradeBundlePackage = NULL;
+    BURN_PACKAGE* pForwardCompatibleBundlePackage = NULL;
+
+    LogId(REPORT_STANDARD, MSG_PLAN_BEGIN, pEngineState->packages.cPackages, LoggingBurnActionToString(action));
+
+    hr = UserExperienceActivateEngine(&pEngineState->userExperience, &fActivated);
+    ExitOnFailure(hr, "Engine cannot start plan because it is busy with another action.");
+
+    fPlanBegan = TRUE;
+    hr = UserExperienceOnPlanBegin(&pEngineState->userExperience, pEngineState->packages.cPackages);
+    ExitOnRootFailure(hr, "BA aborted plan begin.");
+
+    // Always reset the plan.
+    PlanReset(&pEngineState->plan, &pEngineState->packages);
+
+    // Remember the overall action state in the plan since it shapes the changes
+    // we make everywhere.
+    pEngineState->plan.action = action;
+    pEngineState->plan.wzBundleId = pEngineState->registration.sczId;
+    pEngineState->plan.wzBundleProviderKey = pEngineState->registration.sczId;
+
+    hr = PlanSetVariables(action, &pEngineState->variables);
+    ExitOnFailure(hr, "Failed to update action.");
+
+    // Set resume commandline
+    hr = PlanSetResumeCommand(&pEngineState->registration, action, &pEngineState->command, &pEngineState->log);
+    ExitOnFailure(hr, "Failed to set resume command");
+
+    hr = DependencyPlanInitialize(pEngineState, &pEngineState->plan);
+    ExitOnFailure(hr, "Failed to initialize the dependencies for the plan.");
+
+    if (BOOTSTRAPPER_ACTION_LAYOUT == action)
+    {
+        Assert(!pEngineState->plan.fPerMachine);
+
+        // Plan the bundle's layout.
+        hr = PlanLayoutBundle(&pEngineState->plan, pEngineState->registration.sczExecutableName, pEngineState->section.qwBundleSize, &pEngineState->variables, &pEngineState->payloads, &sczLayoutDirectory);
+        ExitOnFailure(hr, "Failed to plan the layout of the bundle.");
+
+        // Plan the packages' layout.
+        hr = PlanPackages(&pEngineState->registration, &pEngineState->userExperience, &pEngineState->packages, &pEngineState->plan, &pEngineState->log, &pEngineState->variables, FALSE, pEngineState->command.display, pEngineState->command.relationType, sczLayoutDirectory, &hSyncpointEvent);
+        ExitOnFailure(hr, "Failed to plan packages.");
+    }
+    else if (BOOTSTRAPPER_ACTION_UPDATE_REPLACE == action || BOOTSTRAPPER_ACTION_UPDATE_REPLACE_EMBEDDED == action)
+    {
+        Assert(!pEngineState->plan.fPerMachine);
+
+        pUpgradeBundlePackage = &pEngineState->update.package;
+
+        hr = PlanUpdateBundle(&pEngineState->userExperience, pUpgradeBundlePackage, &pEngineState->plan, &pEngineState->log, &pEngineState->variables, pEngineState->command.display, pEngineState->command.relationType, &hSyncpointEvent);
+        ExitOnFailure(hr, "Failed to plan update.");
+    }
+    else if (pEngineState->registration.fEnabledForwardCompatibleBundle)
+    {
+        Assert(!pEngineState->plan.fPerMachine);
+
+        pForwardCompatibleBundlePackage = &pEngineState->registration.forwardCompatibleBundle;
+
+        hr = PlanPassThroughBundle(&pEngineState->userExperience, pForwardCompatibleBundlePackage, &pEngineState->plan, &pEngineState->log, &pEngineState->variables, pEngineState->command.display, pEngineState->command.relationType, &hSyncpointEvent);
+        ExitOnFailure(hr, "Failed to plan passthrough.");
+    }
+    else // doing an action that modifies the machine state.
+    {
+        BOOL fContinuePlanning = TRUE; // assume we'll be able to keep planning after registration.
+        pEngineState->plan.fPerMachine = pEngineState->registration.fPerMachine; // default the scope of the plan to the per-machine state of the bundle.
+
+        hr = PlanRegistration(&pEngineState->plan, &pEngineState->registration, pEngineState->command.resumeType, pEngineState->command.relationType, pEngineState->sczIgnoreDependencies, &fContinuePlanning);
+        ExitOnFailure(hr, "Failed to plan registration.");
+
+        if (fContinuePlanning)
+        {
+            // Remember the early index, because we want to be able to insert some related bundles
+            // into the plan before other executed packages. This particularly occurs for uninstallation
+            // of addons and patches, which should be uninstalled before the main product.
+            DWORD dwExecuteActionEarlyIndex = pEngineState->plan.cExecuteActions;
+
+            // Plan the related bundles first to support downgrades with ref-counting.
+            hr = PlanRelatedBundlesBegin(&pEngineState->userExperience, &pEngineState->registration, pEngineState->command.relationType, &pEngineState->plan);
+            ExitOnFailure(hr, "Failed to plan related bundles.");
+
+            hr = PlanPackages(&pEngineState->registration, &pEngineState->userExperience, &pEngineState->packages, &pEngineState->plan, &pEngineState->log, &pEngineState->variables, pEngineState->registration.fInstalled, pEngineState->command.display, pEngineState->command.relationType, NULL, &hSyncpointEvent);
+            ExitOnFailure(hr, "Failed to plan packages.");
+
+            // Schedule the update of related bundles last.
+            hr = PlanRelatedBundlesComplete(&pEngineState->registration, &pEngineState->plan, &pEngineState->log, &pEngineState->variables, &hSyncpointEvent, dwExecuteActionEarlyIndex);
+            ExitOnFailure(hr, "Failed to schedule related bundles.");
+        }
+    }
+
+    // Remove unnecessary actions.
+    hr = PlanFinalizeActions(&pEngineState->plan);
+    ExitOnFailure(hr, "Failed to remove unnecessary actions from plan.");
+
+    // Finally, display all packages and related bundles in the log.
+    LogPackages(pUpgradeBundlePackage, pForwardCompatibleBundlePackage, &pEngineState->packages, &pEngineState->registration.relatedBundles, action);
+
+#ifdef DEBUG
+    PlanDump(&pEngineState->plan);
+#endif
+
+LExit:
+    if (fActivated)
+    {
+        UserExperienceDeactivateEngine(&pEngineState->userExperience);
+    }
+
+    if (fPlanBegan)
+    {
+        UserExperienceOnPlanComplete(&pEngineState->userExperience, hr);
+    }
+
+    LogId(REPORT_STANDARD, MSG_PLAN_COMPLETE, hr);
+    ReleaseStr(sczLayoutDirectory);
+
+    return hr;
+}
+
+extern "C" HRESULT CoreElevate(
+    __in BURN_ENGINE_STATE* pEngineState,
+    __in_opt HWND hwndParent
+    )
+{
+    HRESULT hr = S_OK;
+
+    // If the elevated companion pipe isn't created yet, let's make that happen.
+    if (INVALID_HANDLE_VALUE == pEngineState->companionConnection.hPipe)
+    {
+        if (!pEngineState->sczBundleEngineWorkingPath)
+        {
+            hr = CacheBundleToWorkingDirectory(pEngineState->registration.sczId, pEngineState->registration.sczExecutableName, &pEngineState->userExperience.payloads, &pEngineState->section, &pEngineState->sczBundleEngineWorkingPath);
+            ExitOnFailure(hr, "Failed to cache engine to working directory.");
+        }
+
+        hr = ElevationElevate(pEngineState, hwndParent);
+        ExitOnFailure(hr, "Failed to actually elevate.");
+
+        hr = VariableSetNumeric(&pEngineState->variables, BURN_BUNDLE_ELEVATED, TRUE, TRUE);
+        ExitOnFailure(hr, "Failed to overwrite the %ls built-in variable.", BURN_BUNDLE_ELEVATED);
+    }
+
+LExit:
+    return hr;
+}
+
+extern "C" HRESULT CoreApply(
+    __in BURN_ENGINE_STATE* pEngineState,
+    __in_opt HWND hwndParent
+    )
+{
+    HRESULT hr = S_OK;
+    BOOL fActivated = FALSE;
+    HANDLE hLock = NULL;
+    DWORD cOverallProgressTicks = 0;
+    HANDLE hCacheThread = NULL;
+    BOOL fElevated = FALSE;
+    BOOL fRegistered = FALSE;
+    BOOL fKeepRegistration = pEngineState->plan.fKeepRegistrationDefault;
+    BOOL fRollback = FALSE;
+    BOOL fSuspend = FALSE;
+    BOOTSTRAPPER_APPLY_RESTART restart = BOOTSTRAPPER_APPLY_RESTART_NONE;
+    BURN_CACHE_THREAD_CONTEXT cacheThreadContext = { };
+    DWORD dwPhaseCount = 0;
+    BOOTSTRAPPER_APPLYCOMPLETE_ACTION applyCompleteAction = BOOTSTRAPPER_APPLYCOMPLETE_ACTION_NONE;
+
+    LogId(REPORT_STANDARD, MSG_APPLY_BEGIN);
+
+    hr = UserExperienceActivateEngine(&pEngineState->userExperience, &fActivated);
+    ExitOnFailure(hr, "Engine cannot start apply because it is busy with another action.");
+
+    // Ensure any previous attempts to execute are reset.
+    ApplyReset(&pEngineState->userExperience, &pEngineState->packages);
+
+    if (pEngineState->plan.cCacheActions)
+    {
+        ++dwPhaseCount;
+    }
+    if (pEngineState->plan.cExecuteActions)
+    {
+        ++dwPhaseCount;
+    }
+
+    hr = UserExperienceOnApplyBegin(&pEngineState->userExperience, dwPhaseCount);
+    ExitOnRootFailure(hr, "BA aborted apply begin.");
+
+    // Abort if this bundle already requires a restart.
+    if (BOOTSTRAPPER_RESUME_TYPE_REBOOT_PENDING == pEngineState->command.resumeType)
+    {
+        restart = BOOTSTRAPPER_APPLY_RESTART_REQUIRED;
+
+        hr = HRESULT_FROM_WIN32(ERROR_FAIL_NOACTION_REBOOT);
+        UserExperienceSendError(&pEngineState->userExperience, BOOTSTRAPPER_ERROR_TYPE_APPLY, NULL, hr, NULL, MB_ICONERROR | MB_OK, IDNOACTION); // ignore return value.
+        ExitFunction();
+    }
+
+    hr = ApplyLock(FALSE, &hLock);
+    ExitOnFailure(hr, "Another per-user setup is already executing.");
+
+    // Initialize only after getting a lock.
+    ApplyInitialize();
+
+    pEngineState->userExperience.hwndApply = hwndParent;
+
+    hr = ApplySetVariables(&pEngineState->variables);
+    ExitOnFailure(hr, "Failed to set initial apply variables.");
+
+    // If the plan is empty of work to do, skip everything.
+    if (!(pEngineState->plan.cRegistrationActions || pEngineState->plan.cCacheActions || pEngineState->plan.cExecuteActions || pEngineState->plan.cCleanActions))
+    {
+        LogId(REPORT_STANDARD, MSG_APPLY_SKIPPED);
+        ExitFunction();
+    }
+
+    // Ensure the engine is cached to the working path.
+    if (!pEngineState->sczBundleEngineWorkingPath)
+    {
+        hr = CacheBundleToWorkingDirectory(pEngineState->registration.sczId, pEngineState->registration.sczExecutableName, &pEngineState->userExperience.payloads, &pEngineState->section, &pEngineState->sczBundleEngineWorkingPath);
+        ExitOnFailure(hr, "Failed to cache engine to working directory.");
+    }
+
+    // Elevate.
+    if (pEngineState->plan.fPerMachine)
+    {
+        hr = CoreElevate(pEngineState, pEngineState->userExperience.hwndApply);
+        ExitOnFailure(hr, "Failed to elevate.");
+
+        hr = ElevationApplyInitialize(pEngineState->companionConnection.hPipe, &pEngineState->variables, pEngineState->plan.action, pEngineState->automaticUpdates, !pEngineState->fDisableSystemRestore);
+        ExitOnFailure(hr, "Another per-machine setup is already executing.");
+
+        fElevated = TRUE;
+    }
+
+    // Register.
+    if (pEngineState->plan.fRegister)
+    {
+        hr = ApplyRegister(pEngineState);
+        ExitOnFailure(hr, "Failed to register bundle.");
+        fRegistered = TRUE;
+    }
+
+    // Cache.
+    if (pEngineState->plan.cCacheActions)
+    {
+        // Launch the cache thread.
+        cacheThreadContext.pEngineState = pEngineState;
+        cacheThreadContext.pcOverallProgressTicks = &cOverallProgressTicks;
+        cacheThreadContext.pfRollback = &fRollback;
+
+        hCacheThread = ::CreateThread(NULL, 0, CacheThreadProc, &cacheThreadContext, 0, NULL);
+        ExitOnNullWithLastError(hCacheThread, hr, "Failed to create cache thread.");
+
+        // If we're not caching in parallel, wait for the cache thread to terminate.
+        if (!pEngineState->fParallelCacheAndExecute)
+        {
+            hr = WaitForCacheThread(hCacheThread);
+            ExitOnFailure(hr, "Failed while caching, aborting execution.");
+
+            ReleaseHandle(hCacheThread);
+        }
+    }
+
+    // Execute.
+    if (pEngineState->plan.cExecuteActions)
+    {
+        hr = ApplyExecute(pEngineState, hCacheThread, &cOverallProgressTicks, &fKeepRegistration, &fRollback, &fSuspend, &restart);
+        UserExperienceExecutePhaseComplete(&pEngineState->userExperience, hr); // signal that execute completed.
+    }
+
+    // Wait for cache thread to terminate, this should return immediately unless we're waiting for layout to complete.
+    if (hCacheThread)
+    {
+        HRESULT hrCached = WaitForCacheThread(hCacheThread);
+        if (SUCCEEDED(hr))
+        {
+            hr = hrCached;
+        }
+    }
+
+    // If something went wrong or force restarted, skip cleaning.
+    if (FAILED(hr) || fRollback || fSuspend || BOOTSTRAPPER_APPLY_RESTART_INITIATED == restart)
+    {
+        ExitFunction();
+    }
+
+    // Clean.
+    if (pEngineState->plan.cCleanActions)
+    {
+        ApplyClean(&pEngineState->userExperience, &pEngineState->plan, pEngineState->companionConnection.hPipe);
+    }
+
+LExit:
+    // Unregister.
+    if (fRegistered)
+    {
+        ApplyUnregister(pEngineState, FAILED(hr) || fRollback, fKeepRegistration || pEngineState->plan.fDisallowRemoval, fSuspend, restart);
+    }
+
+    if (fElevated)
+    {
+        ElevationApplyUninitialize(pEngineState->companionConnection.hPipe);
+    }
+
+    pEngineState->userExperience.hwndApply = NULL;
+
+    ApplyUninitialize();
+
+    if (hLock)
+    {
+        ::ReleaseMutex(hLock);
+        ::CloseHandle(hLock);
+    }
+
+    if (fActivated)
+    {
+        UserExperienceDeactivateEngine(&pEngineState->userExperience);
+    }
+
+    ReleaseHandle(hCacheThread);
+
+    UserExperienceOnApplyComplete(&pEngineState->userExperience, hr, restart, &applyCompleteAction);
+    if (BOOTSTRAPPER_APPLYCOMPLETE_ACTION_RESTART == applyCompleteAction)
+    {
+        pEngineState->fRestart = TRUE;
+    }
+
+    LogId(REPORT_STANDARD, MSG_APPLY_COMPLETE, hr, LoggingRestartToString(restart), LoggingBoolToString(pEngineState->fRestart));
+
+    return hr;
+}
+
+extern "C" HRESULT CoreLaunchApprovedExe(
+    __in BURN_ENGINE_STATE* pEngineState,
+    __in BURN_LAUNCH_APPROVED_EXE* pLaunchApprovedExe
+    )
+{
+    HRESULT hr = S_OK;
+    BOOL fActivated = FALSE;
+    DWORD dwProcessId = 0;
+
+    LogId(REPORT_STANDARD, MSG_LAUNCH_APPROVED_EXE_BEGIN, pLaunchApprovedExe->sczId);
+
+    hr = UserExperienceActivateEngine(&pEngineState->userExperience, &fActivated);
+    ExitOnFailure(hr, "Engine cannot start LaunchApprovedExe because it is busy with another action.");
+
+    hr = UserExperienceOnLaunchApprovedExeBegin(&pEngineState->userExperience);
+    ExitOnRootFailure(hr, "BA aborted LaunchApprovedExe begin.");
+
+    // Elevate.
+    hr = CoreElevate(pEngineState, pLaunchApprovedExe->hwndParent);
+    ExitOnFailure(hr, "Failed to elevate.");
+
+    // Launch.
+    hr = ElevationLaunchApprovedExe(pEngineState->companionConnection.hPipe, pLaunchApprovedExe, &dwProcessId);
+
+LExit:
+    if (fActivated)
+    {
+        UserExperienceDeactivateEngine(&pEngineState->userExperience);
+    }
+
+    UserExperienceOnLaunchApprovedExeComplete(&pEngineState->userExperience, hr, dwProcessId);
+
+    LogId(REPORT_STANDARD, MSG_LAUNCH_APPROVED_EXE_COMPLETE, hr, dwProcessId);
+
+    ApprovedExesUninitializeLaunch(pLaunchApprovedExe);
+
+    return hr;
+}
+
+extern "C" HRESULT CoreQuit(
+    __in BURN_ENGINE_STATE* pEngineState,
+    __in int nExitCode
+    )
+{
+    HRESULT hr = S_OK;
+
+    // Save engine state if resume mode is unequal to "none".
+    if (BURN_RESUME_MODE_NONE != pEngineState->resumeMode)
+    {
+        hr = CoreSaveEngineState(pEngineState);
+        if (FAILED(hr))
+        {
+            LogErrorId(hr, MSG_STATE_NOT_SAVED, NULL, NULL, NULL);
+            hr = S_OK;
+        }
+    }
+
+    LogId(REPORT_STANDARD, MSG_QUIT, nExitCode);
+
+    ::PostQuitMessage(nExitCode); // go bye-bye.
+
+    return hr;
+}
+
+extern "C" HRESULT CoreSaveEngineState(
+    __in BURN_ENGINE_STATE* pEngineState
+    )
+{
+    HRESULT hr = S_OK;
+    BYTE* pbBuffer = NULL;
+    SIZE_T cbBuffer = 0;
+
+    // serialize engine state
+    hr = CoreSerializeEngineState(pEngineState, &pbBuffer, &cbBuffer);
+    ExitOnFailure(hr, "Failed to serialize engine state.");
+
+    // write to registration store
+    if (pEngineState->registration.fPerMachine)
+    {
+        hr = ElevationSaveState(pEngineState->companionConnection.hPipe, pbBuffer, cbBuffer);
+        ExitOnFailure(hr, "Failed to save engine state in per-machine process.");
+    }
+    else
+    {
+        hr = RegistrationSaveState(&pEngineState->registration, pbBuffer, cbBuffer);
+        ExitOnFailure(hr, "Failed to save engine state.");
+    }
+
+LExit:
+    ReleaseBuffer(pbBuffer);
+
+    return hr;
+}
+
+extern "C" LPCWSTR CoreRelationTypeToCommandLineString(
+    __in BOOTSTRAPPER_RELATION_TYPE relationType
+    )
+{
+    LPCWSTR wzRelationTypeCommandLine = NULL;
+    switch (relationType)
+    {
+    case BOOTSTRAPPER_RELATION_DETECT:
+        wzRelationTypeCommandLine = BURN_COMMANDLINE_SWITCH_RELATED_DETECT;
+        break;
+    case BOOTSTRAPPER_RELATION_UPGRADE:
+        wzRelationTypeCommandLine = BURN_COMMANDLINE_SWITCH_RELATED_UPGRADE;
+        break;
+    case BOOTSTRAPPER_RELATION_ADDON:
+        wzRelationTypeCommandLine = BURN_COMMANDLINE_SWITCH_RELATED_ADDON;
+        break;
+    case BOOTSTRAPPER_RELATION_PATCH:
+        wzRelationTypeCommandLine = BURN_COMMANDLINE_SWITCH_RELATED_PATCH;
+        break;
+    case BOOTSTRAPPER_RELATION_UPDATE:
+        wzRelationTypeCommandLine = BURN_COMMANDLINE_SWITCH_RELATED_UPDATE;
+        break;
+    case BOOTSTRAPPER_RELATION_DEPENDENT:
+        break;
+    case BOOTSTRAPPER_RELATION_NONE: __fallthrough;
+    default:
+        wzRelationTypeCommandLine = NULL;
+        break;
+    }
+
+    return wzRelationTypeCommandLine;
+}
+
+extern "C" HRESULT CoreRecreateCommandLine(
+    __deref_inout_z LPWSTR* psczCommandLine,
+    __in BOOTSTRAPPER_ACTION action,
+    __in BOOTSTRAPPER_DISPLAY display,
+    __in BOOTSTRAPPER_RESTART restart,
+    __in BOOTSTRAPPER_RELATION_TYPE relationType,
+    __in BOOL fPassthrough,
+    __in_z_opt LPCWSTR wzActiveParent,
+    __in_z_opt LPCWSTR wzAncestors,
+    __in_z_opt LPCWSTR wzAppendLogPath,
+    __in_z_opt LPCWSTR wzAdditionalCommandLineArguments
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR scz = NULL;
+    LPCWSTR wzRelationTypeCommandLine = CoreRelationTypeToCommandLineString(relationType);
+
+    hr = StrAllocString(psczCommandLine, L"", 0);
+    ExitOnFailure(hr, "Failed to empty command line.");
+
+    switch (display)
+    {
+    case BOOTSTRAPPER_DISPLAY_NONE:
+        hr = StrAllocConcat(psczCommandLine, L" /quiet", 0);
+        break;
+    case BOOTSTRAPPER_DISPLAY_PASSIVE:
+        hr = StrAllocConcat(psczCommandLine, L" /passive", 0);
+        break;
+    }
+    ExitOnFailure(hr, "Failed to append display state to command-line");
+
+    switch (action)
+    {
+    case BOOTSTRAPPER_ACTION_MODIFY:
+        hr = StrAllocConcat(psczCommandLine, L" /modify", 0);
+        break;
+    case BOOTSTRAPPER_ACTION_REPAIR:
+        hr = StrAllocConcat(psczCommandLine, L" /repair", 0);
+        break;
+    case BOOTSTRAPPER_ACTION_UNINSTALL:
+        hr = StrAllocConcat(psczCommandLine, L" /uninstall", 0);
+        break;
+    }
+    ExitOnFailure(hr, "Failed to append action state to command-line");
+
+    switch (restart)
+    {
+    case BOOTSTRAPPER_RESTART_ALWAYS:
+        hr = StrAllocConcat(psczCommandLine, L" /forcerestart", 0);
+        break;
+    case BOOTSTRAPPER_RESTART_NEVER:
+        hr = StrAllocConcat(psczCommandLine, L" /norestart", 0);
+        break;
+    }
+    ExitOnFailure(hr, "Failed to append restart state to command-line");
+
+    if (wzActiveParent)
+    {
+        if (*wzActiveParent)
+        {
+            hr = StrAllocFormatted(&scz, L" /%ls \"%ls\"", BURN_COMMANDLINE_SWITCH_PARENT, wzActiveParent);
+            ExitOnFailure(hr, "Failed to format active parent command-line for command-line.");
+        }
+        else
+        {
+            hr = StrAllocFormatted(&scz, L" /%ls", BURN_COMMANDLINE_SWITCH_PARENT_NONE);
+            ExitOnFailure(hr, "Failed to format parent:none command-line for command-line.");
+        }
+
+        hr = StrAllocConcat(psczCommandLine, scz, 0);
+        ExitOnFailure(hr, "Failed to append active parent command-line to command-line.");
+    }
+
+    if (wzAncestors)
+    {
+        hr = StrAllocFormatted(&scz, L" /%ls=%ls", BURN_COMMANDLINE_SWITCH_ANCESTORS, wzAncestors);
+        ExitOnFailure(hr, "Failed to format ancestors for command-line.");
+
+        hr = StrAllocConcat(psczCommandLine, scz, 0);
+        ExitOnFailure(hr, "Failed to append ancestors to command-line.");
+    }
+
+    if (wzRelationTypeCommandLine)
+    {
+        hr = StrAllocFormatted(&scz, L" /%ls", wzRelationTypeCommandLine);
+        ExitOnFailure(hr, "Failed to format relation type for command-line.");
+
+        hr = StrAllocConcat(psczCommandLine, scz, 0);
+        ExitOnFailure(hr, "Failed to append relation type to command-line.");
+    }
+
+    if (fPassthrough)
+    {
+        hr = StrAllocFormatted(&scz, L" /%ls", BURN_COMMANDLINE_SWITCH_PASSTHROUGH);
+        ExitOnFailure(hr, "Failed to format passthrough for command-line.");
+
+        hr = StrAllocConcat(psczCommandLine, scz, 0);
+        ExitOnFailure(hr, "Failed to append passthrough to command-line.");
+    }
+
+    if (wzAppendLogPath && *wzAppendLogPath)
+    {
+        hr = StrAllocFormatted(&scz, L" /%ls \"%ls\"", BURN_COMMANDLINE_SWITCH_LOG_APPEND, wzAppendLogPath);
+        ExitOnFailure(hr, "Failed to format append log command-line for command-line.");
+
+        hr = StrAllocConcat(psczCommandLine, scz, 0);
+        ExitOnFailure(hr, "Failed to append log command-line to command-line");
+    }
+
+    if (wzAdditionalCommandLineArguments && *wzAdditionalCommandLineArguments)
+    {
+        hr = StrAllocConcat(psczCommandLine, L" ", 0);
+        ExitOnFailure(hr, "Failed to append space to command-line.");
+
+        hr = StrAllocConcat(psczCommandLine, wzAdditionalCommandLineArguments, 0);
+        ExitOnFailure(hr, "Failed to append command-line to command-line.");
+    }
+
+LExit:
+    ReleaseStr(scz);
+
+    return hr;
+}
+
+extern "C" HRESULT CoreAppendFileHandleAttachedToCommandLine(
+    __in HANDLE hFileWithAttachedContainer,
+    __out HANDLE* phExecutableFile,
+    __deref_inout_z LPWSTR* psczCommandLine
+    )
+{
+    HRESULT hr = S_OK;
+    HANDLE hExecutableFile = INVALID_HANDLE_VALUE;
+
+    *phExecutableFile = INVALID_HANDLE_VALUE;
+
+    if (!::DuplicateHandle(::GetCurrentProcess(), hFileWithAttachedContainer, ::GetCurrentProcess(), &hExecutableFile, 0, TRUE, DUPLICATE_SAME_ACCESS))
+    {
+        ExitWithLastError(hr, "Failed to duplicate file handle for attached container.");
+    }
+
+    hr = StrAllocFormattedSecure(psczCommandLine, L"%ls -%ls=%u", *psczCommandLine, BURN_COMMANDLINE_SWITCH_FILEHANDLE_ATTACHED, hExecutableFile);
+    ExitOnFailure(hr, "Failed to append the file handle to the command line.");
+
+    *phExecutableFile = hExecutableFile;
+    hExecutableFile = INVALID_HANDLE_VALUE;
+
+LExit:
+    ReleaseFileHandle(hExecutableFile);
+
+    return hr;
+}
+
+extern "C" HRESULT CoreAppendFileHandleSelfToCommandLine(
+    __in LPCWSTR wzExecutablePath,
+    __out HANDLE* phExecutableFile,
+    __deref_inout_z LPWSTR* psczCommandLine,
+    __deref_inout_z_opt LPWSTR* psczObfuscatedCommandLine
+    )
+{
+    HRESULT hr = S_OK;
+    HANDLE hExecutableFile = INVALID_HANDLE_VALUE;
+    SECURITY_ATTRIBUTES securityAttributes = { };
+    securityAttributes.bInheritHandle = TRUE;
+    *phExecutableFile = INVALID_HANDLE_VALUE;
+
+    hExecutableFile = ::CreateFileW(wzExecutablePath, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_DELETE, &securityAttributes, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+    if (INVALID_HANDLE_VALUE != hExecutableFile)
+    {
+        hr = StrAllocFormattedSecure(psczCommandLine, L"%ls -%ls=%u", *psczCommandLine, BURN_COMMANDLINE_SWITCH_FILEHANDLE_SELF, hExecutableFile);
+        ExitOnFailure(hr, "Failed to append the file handle to the command line.");
+
+        if (psczObfuscatedCommandLine)
+        {
+            hr = StrAllocFormatted(psczObfuscatedCommandLine, L"%ls -%ls=%u", *psczObfuscatedCommandLine, BURN_COMMANDLINE_SWITCH_FILEHANDLE_SELF, hExecutableFile);
+            ExitOnFailure(hr, "Failed to append the file handle to the obfuscated command line.");
+        }
+
+        *phExecutableFile = hExecutableFile;
+        hExecutableFile = INVALID_HANDLE_VALUE;
+    }
+
+LExit:
+    ReleaseFileHandle(hExecutableFile);
+
+    return hr;
+}
+
+// internal helper functions
+
+static HRESULT ParseCommandLine(
+    __in int argc,
+    __in LPWSTR* argv,
+    __in BOOTSTRAPPER_COMMAND* pCommand,
+    __in BURN_PIPE_CONNECTION* pCompanionConnection,
+    __in BURN_PIPE_CONNECTION* pEmbeddedConnection,
+    __in BURN_VARIABLES* pVariables,
+    __out BURN_MODE* pMode,
+    __out BURN_AU_PAUSE_ACTION* pAutomaticUpdates,
+    __out BOOL* pfDisableSystemRestore,
+    __out_z LPWSTR* psczSourceProcessPath,
+    __out_z LPWSTR* psczOriginalSource,
+    __out BOOL* pfDisableUnelevate,
+    __out DWORD *pdwLoggingAttributes,
+    __out_z LPWSTR* psczLogFile,
+    __out_z LPWSTR* psczActiveParent,
+    __out_z LPWSTR* psczIgnoreDependencies,
+    __out_z LPWSTR* psczAncestors,
+    __out_z LPWSTR* psczSanitizedCommandLine
+    )
+{
+    HRESULT hr = S_OK;
+    BOOL fUnknownArg = FALSE;
+    BOOL fHidden = FALSE;
+    LPWSTR sczCommandLine = NULL;
+    LPWSTR sczSanitizedArgument = NULL;
+    LPWSTR sczVariableName = NULL;
+
+    for (int i = 0; i < argc; ++i)
+    {
+        fUnknownArg = FALSE;
+        int originalIndex = i;
+        ReleaseNullStr(sczSanitizedArgument);
+
+        if (argv[i][0] == L'-' || argv[i][0] == L'/')
+        {
+            if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, NORM_IGNORECASE, &argv[i][1], -1, L"l", -1) ||
+                CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, NORM_IGNORECASE, &argv[i][1], -1, L"log", -1))
+            {
+                *pdwLoggingAttributes &= ~BURN_LOGGING_ATTRIBUTE_APPEND;
+
+                if (i + 1 >= argc)
+                {
+                    ExitOnRootFailure(hr = E_INVALIDARG, "Must specify a path for log.");
+                }
+
+                ++i;
+
+                hr = StrAllocString(psczLogFile, argv[i], 0);
+                ExitOnFailure(hr, "Failed to copy log file path.");
+            }
+            else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, NORM_IGNORECASE, &argv[i][1], -1, L"?", -1) ||
+                     CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, NORM_IGNORECASE, &argv[i][1], -1, L"h", -1) ||
+                     CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, NORM_IGNORECASE, &argv[i][1], -1, L"help", -1))
+            {
+                pCommand->action = BOOTSTRAPPER_ACTION_HELP;
+            }
+            else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, NORM_IGNORECASE, &argv[i][1], -1, L"q", -1) ||
+                     CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, NORM_IGNORECASE, &argv[i][1], -1, L"quiet", -1) ||
+                     CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, NORM_IGNORECASE, &argv[i][1], -1, L"s", -1) ||
+                     CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, NORM_IGNORECASE, &argv[i][1], -1, L"silent", -1))
+            {
+                pCommand->display = BOOTSTRAPPER_DISPLAY_NONE;
+
+                if (BOOTSTRAPPER_RESTART_UNKNOWN == pCommand->restart)
+                {
+                    pCommand->restart = BOOTSTRAPPER_RESTART_AUTOMATIC;
+                }
+            }
+            else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, NORM_IGNORECASE, &argv[i][1], -1, L"passive", -1))
+            {
+                pCommand->display = BOOTSTRAPPER_DISPLAY_PASSIVE;
+
+                if (BOOTSTRAPPER_RESTART_UNKNOWN == pCommand->restart)
+                {
+                    pCommand->restart = BOOTSTRAPPER_RESTART_AUTOMATIC;
+                }
+            }
+            else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, NORM_IGNORECASE, &argv[i][1], -1, L"norestart", -1))
+            {
+                pCommand->restart = BOOTSTRAPPER_RESTART_NEVER;
+            }
+            else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, NORM_IGNORECASE, &argv[i][1], -1, L"forcerestart", -1))
+            {
+                pCommand->restart = BOOTSTRAPPER_RESTART_ALWAYS;
+            }
+            else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, NORM_IGNORECASE, &argv[i][1], -1, L"promptrestart", -1))
+            {
+                pCommand->restart = BOOTSTRAPPER_RESTART_PROMPT;
+            }
+            else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, NORM_IGNORECASE, &argv[i][1], -1, L"layout", -1))
+            {
+                if (BOOTSTRAPPER_ACTION_HELP != pCommand->action)
+                {
+                    pCommand->action = BOOTSTRAPPER_ACTION_LAYOUT;
+                }
+
+                // If there is another command line argument and it is not a switch, use that as the layout directory.
+                if (i + 1 < argc && argv[i + 1][0] != L'-' && argv[i + 1][0] != L'/')
+                {
+                    ++i;
+
+                    hr = PathExpand(&pCommand->wzLayoutDirectory, argv[i], PATH_EXPAND_ENVIRONMENT | PATH_EXPAND_FULLPATH);
+                    ExitOnFailure(hr, "Failed to copy path for layout directory.");
+                }
+            }
+            else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, NORM_IGNORECASE, &argv[i][1], -1, L"uninstall", -1))
+            {
+                if (BOOTSTRAPPER_ACTION_HELP != pCommand->action)
+                {
+                    pCommand->action = BOOTSTRAPPER_ACTION_UNINSTALL;
+                }
+            }
+            else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, NORM_IGNORECASE, &argv[i][1], -1, L"repair", -1))
+            {
+                if (BOOTSTRAPPER_ACTION_HELP != pCommand->action)
+                {
+                    pCommand->action = BOOTSTRAPPER_ACTION_REPAIR;
+                }
+            }
+            else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, NORM_IGNORECASE, &argv[i][1], -1, L"modify", -1))
+            {
+                if (BOOTSTRAPPER_ACTION_HELP != pCommand->action)
+                {
+                    pCommand->action = BOOTSTRAPPER_ACTION_MODIFY;
+                }
+            }
+            else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, NORM_IGNORECASE, &argv[i][1], -1, L"package", -1) ||
+                     CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, NORM_IGNORECASE, &argv[i][1], -1, L"update", -1))
+            {
+                if (BOOTSTRAPPER_ACTION_UNKNOWN == pCommand->action)
+                {
+                    pCommand->action = BOOTSTRAPPER_ACTION_INSTALL;
+                }
+            }
+            else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, NORM_IGNORECASE, &argv[i][1], -1, L"noaupause", -1))
+            {
+                *pAutomaticUpdates = BURN_AU_PAUSE_ACTION_NONE;
+            }
+            else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, NORM_IGNORECASE, &argv[i][1], -1, L"keepaupaused", -1))
+            {
+                // Switch /noaupause takes precedence.
+                if (BURN_AU_PAUSE_ACTION_NONE != *pAutomaticUpdates)
+                {
+                    *pAutomaticUpdates = BURN_AU_PAUSE_ACTION_IFELEVATED_NORESUME;
+                }
+            }
+            else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, NORM_IGNORECASE, &argv[i][1], -1, L"disablesystemrestore", -1))
+            {
+                *pfDisableSystemRestore = TRUE;
+            }
+            else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, NORM_IGNORECASE, &argv[i][1], -1, L"originalsource", -1))
+            {
+                if (i + 1 >= argc)
+                {
+                    ExitOnRootFailure(hr = E_INVALIDARG, "Must specify a path for original source.");
+                }
+
+                ++i;
+                hr = StrAllocString(psczOriginalSource, argv[i], 0);
+                ExitOnFailure(hr, "Failed to copy last used source.");
+            }
+            else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, NORM_IGNORECASE, &argv[i][1], -1, BURN_COMMANDLINE_SWITCH_PARENT, -1))
+            {
+                if (i + 1 >= argc)
+                {
+                    ExitOnRootFailure(hr = E_INVALIDARG, "Must specify a value for parent.");
+                }
+
+                ++i;
+
+                hr = StrAllocString(psczActiveParent, argv[i], 0);
+                ExitOnFailure(hr, "Failed to copy parent.");
+            }
+            else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, NORM_IGNORECASE, &argv[i][1], -1, BURN_COMMANDLINE_SWITCH_PARENT_NONE, -1))
+            {
+                hr = StrAllocString(psczActiveParent, L"", 0);
+                ExitOnFailure(hr, "Failed to initialize parent to none.");
+            }
+            else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, NORM_IGNORECASE, &argv[i][1], -1, BURN_COMMANDLINE_SWITCH_LOG_APPEND, -1))
+            {
+                if (i + 1 >= argc)
+                {
+                    ExitOnRootFailure(hr = E_INVALIDARG, "Must specify a path for append log.");
+                }
+
+                ++i;
+
+                hr = StrAllocString(psczLogFile, argv[i], 0);
+                ExitOnFailure(hr, "Failed to copy append log file path.");
+
+                *pdwLoggingAttributes |= BURN_LOGGING_ATTRIBUTE_APPEND;
+            }
+            else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, NORM_IGNORECASE, &argv[i][1], -1, BURN_COMMANDLINE_SWITCH_ELEVATED, -1))
+            {
+                if (i + 3 >= argc)
+                {
+                    ExitOnRootFailure(hr = E_INVALIDARG, "Must specify the elevated name, token and parent process id.");
+                }
+
+                if (BURN_MODE_UNTRUSTED != *pMode)
+                {
+                    ExitOnRootFailure(hr = E_INVALIDARG, "Multiple mode command-line switches were provided.");
+                }
+
+                *pMode = BURN_MODE_ELEVATED;
+
+                ++i;
+
+                hr = ParsePipeConnection(argv + i, pCompanionConnection);
+                ExitOnFailure(hr, "Failed to parse elevated connection.");
+
+                i += 2;
+            }
+            else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, NORM_IGNORECASE, &argv[i][1], lstrlenW(BURN_COMMANDLINE_SWITCH_CLEAN_ROOM), BURN_COMMANDLINE_SWITCH_CLEAN_ROOM, lstrlenW(BURN_COMMANDLINE_SWITCH_CLEAN_ROOM)))
+            {
+                // Get a pointer to the next character after the switch.
+                LPCWSTR wzParam = &argv[i][1 + lstrlenW(BURN_COMMANDLINE_SWITCH_CLEAN_ROOM)];
+                if (L'=' != wzParam[0] || L'\0' == wzParam[1])
+                {
+                    ExitOnRootFailure(hr = E_INVALIDARG, "Missing required parameter for switch: %ls", BURN_COMMANDLINE_SWITCH_CLEAN_ROOM);
+                }
+
+                if (BURN_MODE_UNTRUSTED != *pMode)
+                {
+                    ExitOnRootFailure(hr = E_INVALIDARG, "Multiple mode command-line switches were provided.");
+                }
+
+                *pMode = BURN_MODE_NORMAL;
+
+                hr = StrAllocString(psczSourceProcessPath, wzParam + 1, 0);
+                ExitOnFailure(hr, "Failed to copy source process path.");
+            }
+            else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, NORM_IGNORECASE, &argv[i][1], -1, BURN_COMMANDLINE_SWITCH_EMBEDDED, -1))
+            {
+                if (i + 3 >= argc)
+                {
+                    ExitOnRootFailure(hr = E_INVALIDARG, "Must specify the embedded name, token and parent process id.");
+                }
+
+                switch (*pMode)
+                {
+                case BURN_MODE_UNTRUSTED:
+                    // Leave mode as UNTRUSTED to launch the clean room process.
+                    break;
+                case BURN_MODE_NORMAL:
+                    // The initialization code already assumes that the
+                    // clean room switch is at the beginning of the command line,
+                    // so it's safe to assume that the mode is NORMAL in the clean room.
+                    *pMode = BURN_MODE_EMBEDDED;
+                    break;
+                default:
+                    ExitOnRootFailure(hr = E_INVALIDARG, "Multiple mode command-line switches were provided.");
+                }
+
+                ++i;
+
+                hr = ParsePipeConnection(argv + i, pEmbeddedConnection);
+                ExitOnFailure(hr, "Failed to parse embedded connection.");
+
+                i += 2;
+            }
+            else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, NORM_IGNORECASE, &argv[i][1], -1, BURN_COMMANDLINE_SWITCH_RELATED_DETECT, -1))
+            {
+                pCommand->relationType = BOOTSTRAPPER_RELATION_DETECT;
+
+                LogId(REPORT_STANDARD, MSG_BURN_RUN_BY_RELATED_BUNDLE, LoggingRelationTypeToString(pCommand->relationType));
+            }
+            else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, NORM_IGNORECASE, &argv[i][1], -1, BURN_COMMANDLINE_SWITCH_RELATED_UPGRADE, -1))
+            {
+                pCommand->relationType = BOOTSTRAPPER_RELATION_UPGRADE;
+
+                LogId(REPORT_STANDARD, MSG_BURN_RUN_BY_RELATED_BUNDLE, LoggingRelationTypeToString(pCommand->relationType));
+            }
+            else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, NORM_IGNORECASE, &argv[i][1], -1, BURN_COMMANDLINE_SWITCH_RELATED_ADDON, -1))
+            {
+                pCommand->relationType = BOOTSTRAPPER_RELATION_ADDON;
+
+                LogId(REPORT_STANDARD, MSG_BURN_RUN_BY_RELATED_BUNDLE, LoggingRelationTypeToString(pCommand->relationType));
+            }
+            else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, NORM_IGNORECASE, &argv[i][1], -1, BURN_COMMANDLINE_SWITCH_RELATED_PATCH, -1))
+            {
+                pCommand->relationType = BOOTSTRAPPER_RELATION_PATCH;
+
+                LogId(REPORT_STANDARD, MSG_BURN_RUN_BY_RELATED_BUNDLE, LoggingRelationTypeToString(pCommand->relationType));
+            }
+            else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, NORM_IGNORECASE, &argv[i][1], -1, BURN_COMMANDLINE_SWITCH_RELATED_UPDATE, -1))
+            {
+                pCommand->relationType = BOOTSTRAPPER_RELATION_UPDATE;
+
+                LogId(REPORT_STANDARD, MSG_BURN_RUN_BY_RELATED_BUNDLE, LoggingRelationTypeToString(pCommand->relationType));
+            }
+            else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, NORM_IGNORECASE, &argv[i][1], -1, BURN_COMMANDLINE_SWITCH_PASSTHROUGH, -1))
+            {
+                pCommand->fPassthrough = TRUE;
+            }
+            else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, NORM_IGNORECASE, &argv[i][1], -1, BURN_COMMANDLINE_SWITCH_DISABLE_UNELEVATE, -1))
+            {
+                *pfDisableUnelevate = TRUE;
+            }
+            else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, NORM_IGNORECASE, &argv[i][1], -1, BURN_COMMANDLINE_SWITCH_RUNONCE, -1))
+            {
+                if (BURN_MODE_UNTRUSTED != *pMode)
+                {
+                    ExitOnRootFailure(hr = E_INVALIDARG, "Multiple mode command-line switches were provided.");
+                }
+
+                *pMode = BURN_MODE_RUNONCE;
+            }
+            else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, NORM_IGNORECASE, &argv[i][1], lstrlenW(BURN_COMMANDLINE_SWITCH_IGNOREDEPENDENCIES), BURN_COMMANDLINE_SWITCH_IGNOREDEPENDENCIES, lstrlenW(BURN_COMMANDLINE_SWITCH_IGNOREDEPENDENCIES)))
+            {
+                // Get a pointer to the next character after the switch.
+                LPCWSTR wzParam = &argv[i][1 + lstrlenW(BURN_COMMANDLINE_SWITCH_IGNOREDEPENDENCIES)];
+                if (L'=' != wzParam[0] || L'\0' == wzParam[1])
+                {
+                    ExitOnRootFailure(hr = E_INVALIDARG, "Missing required parameter for switch: %ls", BURN_COMMANDLINE_SWITCH_IGNOREDEPENDENCIES);
+                }
+
+                hr = StrAllocString(psczIgnoreDependencies, &wzParam[1], 0);
+                ExitOnFailure(hr, "Failed to allocate the list of dependencies to ignore.");
+            }
+            else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, NORM_IGNORECASE, &argv[i][1], lstrlenW(BURN_COMMANDLINE_SWITCH_ANCESTORS), BURN_COMMANDLINE_SWITCH_ANCESTORS, lstrlenW(BURN_COMMANDLINE_SWITCH_ANCESTORS)))
+            {
+                // Get a pointer to the next character after the switch.
+                LPCWSTR wzParam = &argv[i][1 + lstrlenW(BURN_COMMANDLINE_SWITCH_ANCESTORS)];
+                if (L'=' != wzParam[0] || L'\0' == wzParam[1])
+                {
+                    ExitOnRootFailure(hr = E_INVALIDARG, "Missing required parameter for switch: %ls", BURN_COMMANDLINE_SWITCH_ANCESTORS);
+                }
+
+                hr = StrAllocString(psczAncestors, &wzParam[1], 0);
+                ExitOnFailure(hr, "Failed to allocate the list of ancestors.");
+            }
+            else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, NORM_IGNORECASE, &argv[i][1], lstrlenW(BURN_COMMANDLINE_SWITCH_FILEHANDLE_ATTACHED), BURN_COMMANDLINE_SWITCH_FILEHANDLE_ATTACHED, lstrlenW(BURN_COMMANDLINE_SWITCH_FILEHANDLE_ATTACHED)))
+            {
+                // Already processed in InitializeEngineState.
+            }
+            else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, NORM_IGNORECASE, &argv[i][1], lstrlenW(BURN_COMMANDLINE_SWITCH_FILEHANDLE_SELF), BURN_COMMANDLINE_SWITCH_FILEHANDLE_SELF, lstrlenW(BURN_COMMANDLINE_SWITCH_FILEHANDLE_SELF)))
+            {
+                // Already processed in InitializeEngineState.
+            }
+            else if (lstrlenW(&argv[i][1]) >= lstrlenW(BURN_COMMANDLINE_SWITCH_PREFIX) &&
+                CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, NORM_IGNORECASE, &argv[i][1], lstrlenW(BURN_COMMANDLINE_SWITCH_PREFIX), BURN_COMMANDLINE_SWITCH_PREFIX, lstrlenW(BURN_COMMANDLINE_SWITCH_PREFIX)))
+            {
+                // Skip (but log) any other private burn switches we don't recognize, so that
+                // adding future private variables doesn't break old bundles
+                LogId(REPORT_STANDARD, MSG_BURN_UNKNOWN_PRIVATE_SWITCH, &argv[i][1]);
+            }
+            else
+            {
+                fUnknownArg = TRUE;
+            }
+        }
+        else
+        {
+            fUnknownArg = TRUE;
+
+            const wchar_t* pwc = wcschr(argv[i], L'=');
+            if (pwc)
+            {
+                hr = StrAllocString(&sczVariableName, argv[i], pwc - argv[i]);
+                ExitOnFailure(hr, "Failed to copy variable name.");
+
+                hr = VariableIsHidden(pVariables, sczVariableName, &fHidden);
+                ExitOnFailure(hr, "Failed to determine whether variable is hidden.");
+
+                if (fHidden)
+                {
+                    hr = StrAllocFormatted(&sczSanitizedArgument, L"%ls=*****", sczVariableName);
+                    ExitOnFailure(hr, "Failed to copy sanitized argument.");
+                }
+            }
+        }
+
+        // Remember command-line switch to pass off to UX.
+        if (fUnknownArg)
+        {
+            PathCommandLineAppend(&pCommand->wzCommandLine, argv[i]);
+        }
+
+        if (sczSanitizedArgument)
+        {
+            PathCommandLineAppend(psczSanitizedCommandLine, sczSanitizedArgument);
+        }
+        else
+        {
+            for (; originalIndex <= i; ++originalIndex)
+            {
+                PathCommandLineAppend(psczSanitizedCommandLine, argv[originalIndex]);
+            }
+        }
+    }
+
+    // If embedded, ensure the display goes embedded as well.
+    if (BURN_MODE_EMBEDDED == *pMode)
+    {
+        pCommand->display = BOOTSTRAPPER_DISPLAY_EMBEDDED;
+    }
+
+    // Set the defaults if nothing was set above.
+    if (BOOTSTRAPPER_ACTION_UNKNOWN == pCommand->action)
+    {
+        pCommand->action = BOOTSTRAPPER_ACTION_INSTALL;
+    }
+
+    if (BOOTSTRAPPER_DISPLAY_UNKNOWN == pCommand->display)
+    {
+        pCommand->display = BOOTSTRAPPER_DISPLAY_FULL;
+    }
+
+    if (BOOTSTRAPPER_RESTART_UNKNOWN == pCommand->restart)
+    {
+        pCommand->restart = BOOTSTRAPPER_RESTART_PROMPT;
+    }
+
+LExit:
+    ReleaseStr(sczVariableName);
+    ReleaseStr(sczSanitizedArgument);
+    ReleaseStr(sczCommandLine);
+
+    return hr;
+}
+
+static HRESULT ParsePipeConnection(
+    __in_ecount(3) LPWSTR* rgArgs,
+    __in BURN_PIPE_CONNECTION* pConnection
+    )
+{
+    HRESULT hr = S_OK;
+
+    hr = StrAllocString(&pConnection->sczName, rgArgs[0], 0);
+    ExitOnFailure(hr, "Failed to copy connection name from command line.");
+
+    hr = StrAllocString(&pConnection->sczSecret, rgArgs[1], 0);
+    ExitOnFailure(hr, "Failed to copy connection secret from command line.");
+
+    hr = StrStringToUInt32(rgArgs[2], 0, reinterpret_cast<UINT*>(&pConnection->dwProcessId));
+    ExitOnFailure(hr, "Failed to copy parent process id from command line.");
+
+LExit:
+    return hr;
+}
+
+static HRESULT DetectPackage(
+    __in BURN_ENGINE_STATE* pEngineState,
+    __in BURN_PACKAGE* pPackage
+    )
+{
+    HRESULT hr = S_OK;
+    BOOL fBegan = FALSE;
+    
+    fBegan = TRUE;
+    hr = UserExperienceOnDetectPackageBegin(&pEngineState->userExperience, pPackage->sczId);
+    ExitOnRootFailure(hr, "BA aborted detect package begin.");
+
+    // Detect the cache state of the package.
+    hr = DetectPackagePayloadsCached(pPackage);
+    ExitOnFailure(hr, "Failed to detect if payloads are all cached for package: %ls", pPackage->sczId);
+
+    // Use the correct engine to detect the package.
+    switch (pPackage->type)
+    {
+    case BURN_PACKAGE_TYPE_EXE:
+        hr = ExeEngineDetectPackage(pPackage, &pEngineState->variables);
+        break;
+
+    case BURN_PACKAGE_TYPE_MSI:
+        hr = MsiEngineDetectPackage(pPackage, &pEngineState->userExperience);
+        break;
+
+    case BURN_PACKAGE_TYPE_MSP:
+        hr = MspEngineDetectPackage(pPackage, &pEngineState->userExperience);
+        break;
+
+    case BURN_PACKAGE_TYPE_MSU:
+        hr = MsuEngineDetectPackage(pPackage, &pEngineState->variables);
+        break;
+
+    default:
+        hr = E_NOTIMPL;
+        ExitOnRootFailure(hr, "Package type not supported by detect yet.");
+    }
+
+    // TODO: consider how to notify the UX that a package is cached.
+    //else if (BOOTSTRAPPER_PACKAGE_STATE_CACHED > pPackage->currentState && pPackage->fCached)
+    //{
+    //     pPackage->currentState = BOOTSTRAPPER_PACKAGE_STATE_CACHED;
+    //}
+
+LExit:
+    if (FAILED(hr))
+    {
+        LogErrorId(hr, MSG_FAILED_DETECT_PACKAGE, pPackage->sczId, NULL, NULL);
+    }
+
+    if (fBegan)
+    {
+        UserExperienceOnDetectPackageComplete(&pEngineState->userExperience, pPackage->sczId, hr, pPackage->currentState);
+    }
+
+    return hr;
+}
+
+static HRESULT DetectPackagePayloadsCached(
+    __in BURN_PACKAGE* pPackage
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR sczCachePath = NULL;
+    BURN_CACHE_STATE cache = BURN_CACHE_STATE_NONE; // assume the package will not be cached.
+    LPWSTR sczPayloadCachePath = NULL;
+    LONGLONG llSize = 0;
+
+    if (pPackage->sczCacheId && *pPackage->sczCacheId)
+    {
+        hr = CacheGetCompletedPath(pPackage->fPerMachine, pPackage->sczCacheId, &sczCachePath);
+        ExitOnFailure(hr, "Failed to get completed cache path.");
+
+        // If the cached directory exists, we have something.
+        if (DirExists(sczCachePath, NULL))
+        {
+            cache = BURN_CACHE_STATE_COMPLETE; // assume all payloads are cached.
+
+            // Check all payloads to see if any are missing or not the right size.
+            for (DWORD i = 0; i < pPackage->cPayloads; ++i)
+            {
+                BURN_PACKAGE_PAYLOAD* pPackagePayload = pPackage->rgPayloads + i;
+
+                hr = PathConcat(sczCachePath, pPackagePayload->pPayload->sczFilePath, &sczPayloadCachePath);
+                ExitOnFailure(hr, "Failed to concat payload cache path.");
+
+                hr = FileSize(sczPayloadCachePath, &llSize);
+                if (SUCCEEDED(hr) && static_cast<DWORD64>(llSize) != pPackagePayload->pPayload->qwFileSize)
+                {
+                    hr = HRESULT_FROM_WIN32(ERROR_FILE_CORRUPT); // size did not match expectations, so cache must have the wrong file.
+                }
+
+                if (SUCCEEDED(hr))
+                {
+                    // TODO: should we do a full on hash verification on the file to ensure
+                    //       the exact right file is cached?
+
+                    pPackagePayload->fCached = TRUE;
+                }
+                else
+                {
+                    LogId(REPORT_STANDARD, MSG_DETECT_PACKAGE_NOT_FULLY_CACHED, pPackage->sczId, pPackagePayload->pPayload->sczKey, hr);
+
+                    cache = BURN_CACHE_STATE_PARTIAL; // found a payload that was not cached so we are partial.
+                    hr = S_OK;
+                }
+            }
+        }
+    }
+
+    pPackage->cache = cache;
+
+LExit:
+    ReleaseStr(sczPayloadCachePath);
+    ReleaseStr(sczCachePath);
+    return hr;
+}
+
+static DWORD WINAPI CacheThreadProc(
+    __in LPVOID lpThreadParameter
+    )
+{
+    HRESULT hr = S_OK;
+    BURN_CACHE_THREAD_CONTEXT* pContext = reinterpret_cast<BURN_CACHE_THREAD_CONTEXT*>(lpThreadParameter);
+    BURN_ENGINE_STATE* pEngineState = pContext->pEngineState;
+    DWORD* pcOverallProgressTicks = pContext->pcOverallProgressTicks;
+    BOOL* pfRollback = pContext->pfRollback;
+    BOOL fComInitialized = FALSE;
+
+    // initialize COM
+    hr = ::CoInitializeEx(NULL, COINIT_MULTITHREADED);
+    ExitOnFailure(hr, "Failed to initialize COM on cache thread.");
+    fComInitialized = TRUE;
+
+    // cache packages
+    hr = ApplyCache(pEngineState->section.hSourceEngineFile, &pEngineState->userExperience, &pEngineState->variables, &pEngineState->plan, pEngineState->companionConnection.hCachePipe, pcOverallProgressTicks, pfRollback);
+
+LExit:
+    UserExperienceExecutePhaseComplete(&pEngineState->userExperience, hr); // signal that cache completed.
+
+    if (fComInitialized)
+    {
+        ::CoUninitialize();
+    }
+
+    return (DWORD)hr;
+}
+
+static HRESULT WaitForCacheThread(
+    __in HANDLE hCacheThread
+    )
+{
+    HRESULT hr = S_OK;
+
+    if (WAIT_OBJECT_0 != ::WaitForSingleObject(hCacheThread, INFINITE))
+    {
+        ExitWithLastError(hr, "Failed to wait for cache thread to terminate.");
+    }
+
+    if (!::GetExitCodeThread(hCacheThread, (DWORD*)&hr))
+    {
+        ExitWithLastError(hr, "Failed to get cache thread exit code.");
+    }
+
+LExit:
+    return hr;
+}
+
+static void LogPackages(
+    __in_opt const BURN_PACKAGE* pUpgradeBundlePackage,
+    __in_opt const BURN_PACKAGE* pForwardCompatibleBundlePackage,
+    __in const BURN_PACKAGES* pPackages,
+    __in const BURN_RELATED_BUNDLES* pRelatedBundles,
+    __in const BOOTSTRAPPER_ACTION action
+    )
+{
+    if (pUpgradeBundlePackage)
+    {
+        LogId(REPORT_STANDARD, MSG_PLANNED_UPGRADE_BUNDLE, pUpgradeBundlePackage->sczId, LoggingRequestStateToString(pUpgradeBundlePackage->defaultRequested), LoggingRequestStateToString(pUpgradeBundlePackage->requested), LoggingActionStateToString(pUpgradeBundlePackage->execute), LoggingActionStateToString(pUpgradeBundlePackage->rollback), LoggingDependencyActionToString(pUpgradeBundlePackage->dependencyExecute));
+    }
+    else if (pForwardCompatibleBundlePackage)
+    {
+        LogId(REPORT_STANDARD, MSG_PLANNED_FORWARD_COMPATIBLE_BUNDLE, pForwardCompatibleBundlePackage->sczId, LoggingRequestStateToString(pForwardCompatibleBundlePackage->defaultRequested), LoggingRequestStateToString(pForwardCompatibleBundlePackage->requested), LoggingActionStateToString(pForwardCompatibleBundlePackage->execute), LoggingActionStateToString(pForwardCompatibleBundlePackage->rollback), LoggingDependencyActionToString(pForwardCompatibleBundlePackage->dependencyExecute));
+    }
+    else
+    {
+        // Display related bundles first if uninstalling.
+        if (BOOTSTRAPPER_ACTION_UNINSTALL == action && 0 < pRelatedBundles->cRelatedBundles)
+        {
+            for (int i = pRelatedBundles->cRelatedBundles - 1; 0 <= i; --i)
+            {
+                const BURN_RELATED_BUNDLE* pRelatedBundle = &pRelatedBundles->rgRelatedBundles[i];
+                const BURN_PACKAGE* pPackage = &pRelatedBundle->package;
+
+                LogId(REPORT_STANDARD, MSG_PLANNED_RELATED_BUNDLE, pPackage->sczId, LoggingRelationTypeToString(pRelatedBundle->relationType), LoggingRequestStateToString(pPackage->defaultRequested), LoggingRequestStateToString(pPackage->requested), LoggingActionStateToString(pPackage->execute), LoggingActionStateToString(pPackage->rollback), LoggingDependencyActionToString(pPackage->dependencyExecute));
+            }
+        }
+
+        // Display all the packages in the log.
+        for (DWORD i = 0; i < pPackages->cPackages; ++i)
+        {
+            const DWORD iPackage = (BOOTSTRAPPER_ACTION_UNINSTALL == action) ? pPackages->cPackages - 1 - i : i;
+            const BURN_PACKAGE* pPackage = &pPackages->rgPackages[iPackage];
+
+            LogId(REPORT_STANDARD, MSG_PLANNED_PACKAGE, pPackage->sczId, LoggingPackageStateToString(pPackage->currentState), LoggingRequestStateToString(pPackage->defaultRequested), LoggingRequestStateToString(pPackage->requested), LoggingActionStateToString(pPackage->execute), LoggingActionStateToString(pPackage->rollback), LoggingBoolToString(pPackage->fAcquire), LoggingBoolToString(pPackage->fUncache), LoggingDependencyActionToString(pPackage->dependencyExecute));
+        }
+
+        for (DWORD i = 0; i < pPackages->cCompatiblePackages; ++i)
+        {
+            const DWORD iPackage = (BOOTSTRAPPER_ACTION_UNINSTALL == action) ? pPackages->cCompatiblePackages - 1 - i : i;
+            const BURN_PACKAGE* pPackage = &pPackages->rgCompatiblePackages[iPackage];
+
+            LogId(REPORT_STANDARD, MSG_PLANNED_PACKAGE, pPackage->sczId, LoggingPackageStateToString(pPackage->currentState), LoggingRequestStateToString(pPackage->defaultRequested), LoggingRequestStateToString(pPackage->requested), LoggingActionStateToString(pPackage->execute), LoggingActionStateToString(pPackage->rollback), LoggingBoolToString(pPackage->fAcquire), LoggingBoolToString(pPackage->fUncache), LoggingDependencyActionToString(pPackage->dependencyExecute));
+        }
+
+        // Display related bundles last if caching, installing, modifying, or repairing.
+        if (BOOTSTRAPPER_ACTION_UNINSTALL < action && 0 < pRelatedBundles->cRelatedBundles)
+        {
+            for (DWORD i = 0; i < pRelatedBundles->cRelatedBundles; ++i)
+            {
+                const BURN_RELATED_BUNDLE* pRelatedBundle = &pRelatedBundles->rgRelatedBundles[i];
+                const BURN_PACKAGE* pPackage = &pRelatedBundle->package;
+
+                LogId(REPORT_STANDARD, MSG_PLANNED_RELATED_BUNDLE, pPackage->sczId, LoggingRelationTypeToString(pRelatedBundle->relationType), LoggingRequestStateToString(pPackage->defaultRequested), LoggingRequestStateToString(pPackage->requested), LoggingActionStateToString(pPackage->execute), LoggingActionStateToString(pPackage->rollback), LoggingDependencyActionToString(pPackage->dependencyExecute));
+            }
+        }
+    }
+}
diff --git a/src/engine/core.h b/src/engine/core.h
new file mode 100644
index 00000000..6a6da2b1
--- /dev/null
+++ b/src/engine/core.h
@@ -0,0 +1,211 @@
+#pragma once
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+
+// constants
+
+const LPCWSTR BURN_POLICY_REGISTRY_PATH = L"WiX\\Burn";
+
+const LPCWSTR BURN_COMMANDLINE_SWITCH_PARENT = L"parent";
+const LPCWSTR BURN_COMMANDLINE_SWITCH_PARENT_NONE = L"parent:none";
+const LPCWSTR BURN_COMMANDLINE_SWITCH_CLEAN_ROOM = L"burn.clean.room";
+const LPCWSTR BURN_COMMANDLINE_SWITCH_ELEVATED = L"burn.elevated";
+const LPCWSTR BURN_COMMANDLINE_SWITCH_EMBEDDED = L"burn.embedded";
+const LPCWSTR BURN_COMMANDLINE_SWITCH_RUNONCE = L"burn.runonce";
+const LPCWSTR BURN_COMMANDLINE_SWITCH_LOG_APPEND = L"burn.log.append";
+const LPCWSTR BURN_COMMANDLINE_SWITCH_RELATED_DETECT = L"burn.related.detect";
+const LPCWSTR BURN_COMMANDLINE_SWITCH_RELATED_UPGRADE = L"burn.related.upgrade";
+const LPCWSTR BURN_COMMANDLINE_SWITCH_RELATED_ADDON = L"burn.related.addon";
+const LPCWSTR BURN_COMMANDLINE_SWITCH_RELATED_PATCH = L"burn.related.patch";
+const LPCWSTR BURN_COMMANDLINE_SWITCH_RELATED_UPDATE = L"burn.related.update";
+const LPCWSTR BURN_COMMANDLINE_SWITCH_PASSTHROUGH = L"burn.passthrough";
+const LPCWSTR BURN_COMMANDLINE_SWITCH_DISABLE_UNELEVATE = L"burn.disable.unelevate";
+const LPCWSTR BURN_COMMANDLINE_SWITCH_IGNOREDEPENDENCIES = L"burn.ignoredependencies";
+const LPCWSTR BURN_COMMANDLINE_SWITCH_ANCESTORS = L"burn.ancestors";
+const LPCWSTR BURN_COMMANDLINE_SWITCH_FILEHANDLE_ATTACHED = L"burn.filehandle.attached";
+const LPCWSTR BURN_COMMANDLINE_SWITCH_FILEHANDLE_SELF = L"burn.filehandle.self";
+const LPCWSTR BURN_COMMANDLINE_SWITCH_PREFIX = L"burn.";
+
+const LPCWSTR BURN_BUNDLE_LAYOUT_DIRECTORY = L"WixBundleLayoutDirectory";
+const LPCWSTR BURN_BUNDLE_ACTION = L"WixBundleAction";
+const LPCWSTR BURN_BUNDLE_ACTIVE_PARENT = L"WixBundleActiveParent";
+const LPCWSTR BURN_BUNDLE_EXECUTE_PACKAGE_CACHE_FOLDER = L"WixBundleExecutePackageCacheFolder";
+const LPCWSTR BURN_BUNDLE_EXECUTE_PACKAGE_ACTION = L"WixBundleExecutePackageAction";
+const LPCWSTR BURN_BUNDLE_FORCED_RESTART_PACKAGE = L"WixBundleForcedRestartPackage";
+const LPCWSTR BURN_BUNDLE_INSTALLED = L"WixBundleInstalled";
+const LPCWSTR BURN_BUNDLE_ELEVATED = L"WixBundleElevated";
+const LPCWSTR BURN_BUNDLE_PROVIDER_KEY = L"WixBundleProviderKey";
+const LPCWSTR BURN_BUNDLE_MANUFACTURER = L"WixBundleManufacturer";
+const LPCWSTR BURN_BUNDLE_SOURCE_PROCESS_PATH = L"WixBundleSourceProcessPath";
+const LPCWSTR BURN_BUNDLE_SOURCE_PROCESS_FOLDER = L"WixBundleSourceProcessFolder";
+const LPCWSTR BURN_BUNDLE_TAG = L"WixBundleTag";
+const LPCWSTR BURN_BUNDLE_UILEVEL = L"WixBundleUILevel";
+const LPCWSTR BURN_BUNDLE_VERSION = L"WixBundleVersion";
+
+// The following constants must stay in sync with src\wix\Binder.cs
+const LPCWSTR BURN_BUNDLE_NAME = L"WixBundleName";
+const LPCWSTR BURN_BUNDLE_ORIGINAL_SOURCE = L"WixBundleOriginalSource";
+const LPCWSTR BURN_BUNDLE_ORIGINAL_SOURCE_FOLDER = L"WixBundleOriginalSourceFolder";
+const LPCWSTR BURN_BUNDLE_LAST_USED_SOURCE = L"WixBundleLastUsedSource";
+
+
+// enums
+
+enum BURN_MODE
+{
+    BURN_MODE_UNTRUSTED,
+    BURN_MODE_NORMAL,
+    BURN_MODE_ELEVATED,
+    BURN_MODE_EMBEDDED,
+    BURN_MODE_RUNONCE,
+};
+
+enum BURN_AU_PAUSE_ACTION
+{
+    BURN_AU_PAUSE_ACTION_NONE,
+    BURN_AU_PAUSE_ACTION_IFELEVATED,
+    BURN_AU_PAUSE_ACTION_IFELEVATED_NORESUME,
+};
+
+
+// structs
+
+typedef struct _BURN_ENGINE_STATE
+{
+    // synchronization
+    CRITICAL_SECTION csActive; // Any call from the UX that reads or alters the engine state
+                               // needs to be syncronized through this critical section.
+                               // Note: The engine must never do a UX callback while in this critical section.
+
+    // UX flow control
+    //BOOL fSuspend;             // Is TRUE when UX made Suspend() call on core.
+    //BOOL fForcedReboot;        // Is TRUE when UX made Reboot() call on core.
+    //BOOL fCancelled;           // Is TRUE when UX return cancel on UX OnXXX() methods.
+    //BOOL fReboot;              // Is TRUE when UX confirms OnRestartRequried().
+    BOOL fRestart;               // Set TRUE when UX returns IDRESTART during Apply().
+
+    // engine data
+    BOOTSTRAPPER_COMMAND command;
+    BURN_SECTION section;
+    BURN_VARIABLES variables;
+    BURN_CONDITION condition;
+    BURN_SEARCHES searches;
+    BURN_USER_EXPERIENCE userExperience;
+    BURN_REGISTRATION registration;
+    BURN_CONTAINERS containers;
+    BURN_CATALOGS catalogs;
+    BURN_PAYLOADS payloads;
+    BURN_PACKAGES packages;
+    BURN_UPDATE update;
+    BURN_APPROVED_EXES approvedExes;
+
+    HWND hMessageWindow;
+    HANDLE hMessageWindowThread;
+
+    BOOL fDisableRollback;
+    BOOL fDisableSystemRestore;
+    BOOL fParallelCacheAndExecute;
+
+    BURN_LOGGING log;
+
+    BURN_PLAN plan;
+
+    BURN_MODE mode;
+    BURN_AU_PAUSE_ACTION automaticUpdates;
+
+    DWORD dwElevatedLoggingTlsId;
+
+    LPWSTR sczBundleEngineWorkingPath;
+    BURN_PIPE_CONNECTION companionConnection;
+    BURN_PIPE_CONNECTION embeddedConnection;
+
+    BURN_RESUME_MODE resumeMode;
+    BOOL fDisableUnelevate;
+
+    LPWSTR sczIgnoreDependencies;
+
+    int argc;
+    LPWSTR* argv;
+} BURN_ENGINE_STATE;
+
+
+// function declarations
+
+HRESULT CoreInitialize(
+    __in BURN_ENGINE_STATE* pEngineState
+    );
+HRESULT CoreSerializeEngineState(
+    __in BURN_ENGINE_STATE* pEngineState,
+    __inout BYTE** ppbBuffer,
+    __inout SIZE_T* piBuffer
+    );
+HRESULT CoreQueryRegistration(
+    __in BURN_ENGINE_STATE* pEngineState
+    );
+//HRESULT CoreDeserializeEngineState(
+//    __in BURN_ENGINE_STATE* pEngineState,
+//    __in_bcount(cbBuffer) BYTE* pbBuffer,
+//    __in SIZE_T cbBuffer
+//    );
+HRESULT CoreDetect(
+    __in BURN_ENGINE_STATE* pEngineState,
+    __in_opt HWND hwndParent
+    );
+HRESULT CorePlan(
+    __in BURN_ENGINE_STATE* pEngineState,
+    __in BOOTSTRAPPER_ACTION action
+    );
+HRESULT CoreElevate(
+    __in BURN_ENGINE_STATE* pEngineState,
+    __in_opt HWND hwndParent
+    );
+HRESULT CoreApply(
+    __in BURN_ENGINE_STATE* pEngineState,
+    __in_opt HWND hwndParent
+    );
+HRESULT CoreLaunchApprovedExe(
+    __in BURN_ENGINE_STATE* pEngineState,
+    __in BURN_LAUNCH_APPROVED_EXE* pLaunchApprovedExe
+    );
+HRESULT CoreQuit(
+    __in BURN_ENGINE_STATE* pEngineState,
+    __in int nExitCode
+    );
+HRESULT CoreSaveEngineState(
+    __in BURN_ENGINE_STATE* pEngineState
+    );
+LPCWSTR CoreRelationTypeToCommandLineString(
+    __in BOOTSTRAPPER_RELATION_TYPE relationType
+    );
+HRESULT CoreRecreateCommandLine(
+    __deref_inout_z LPWSTR* psczCommandLine,
+    __in BOOTSTRAPPER_ACTION action,
+    __in BOOTSTRAPPER_DISPLAY display,
+    __in BOOTSTRAPPER_RESTART restart,
+    __in BOOTSTRAPPER_RELATION_TYPE relationType,
+    __in BOOL fPassthrough,
+    __in_z_opt LPCWSTR wzActiveParent,
+    __in_z_opt LPCWSTR wzAncestors,
+    __in_z_opt LPCWSTR wzAppendLogPath,
+    __in_z_opt LPCWSTR wzAdditionalCommandLineArguments
+    );
+HRESULT CoreAppendFileHandleAttachedToCommandLine(
+    __in HANDLE hFileWithAttachedContainer,
+    __out HANDLE* phExecutableFile,
+    __deref_inout_z LPWSTR* psczCommandLine
+    );
+HRESULT CoreAppendFileHandleSelfToCommandLine(
+    __in LPCWSTR wzExecutablePath,
+    __out HANDLE* phExecutableFile,
+    __deref_inout_z LPWSTR* psczCommandLine,
+    __deref_inout_z_opt LPWSTR* psczObfuscatedCommandLine
+    );
+
+#if defined(__cplusplus)
+}
+#endif
diff --git a/src/engine/dependency.cpp b/src/engine/dependency.cpp
new file mode 100644
index 00000000..c7c6e024
--- /dev/null
+++ b/src/engine/dependency.cpp
@@ -0,0 +1,1203 @@
+// 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.
+
+#include "precomp.h"
+
+// constants
+
+#define INITIAL_STRINGDICT_SIZE 48
+const LPCWSTR vcszIgnoreDependenciesDelim = L";";
+
+
+// internal function declarations
+
+static HRESULT SplitIgnoreDependencies(
+    __in_z LPCWSTR wzIgnoreDependencies,
+    __deref_inout_ecount_opt(*pcDependencies) DEPENDENCY** prgDependencies,
+    __inout LPUINT pcDependencies
+    );
+
+static HRESULT JoinIgnoreDependencies(
+    __out_z LPWSTR* psczIgnoreDependencies,
+    __in_ecount(cDependencies) const DEPENDENCY* rgDependencies,
+    __in UINT cDependencies
+    );
+
+static HRESULT GetIgnoredDependents(
+    __in const BURN_PACKAGE* pPackage,
+    __in const BURN_PLAN* pPlan,
+    __deref_inout STRINGDICT_HANDLE* psdIgnoredDependents
+    );
+
+static HRESULT GetProviderInformation(
+    __in HKEY hkRoot,
+    __in_z LPCWSTR wzProviderKey,
+    __deref_opt_out_z_opt LPWSTR* psczProviderKey,
+    __deref_opt_out_z_opt LPWSTR* psczId
+    );
+
+static void CalculateDependencyActionStates(
+    __in const BURN_PACKAGE* pPackage,
+    __in const BOOTSTRAPPER_ACTION action,
+    __out BURN_DEPENDENCY_ACTION* pDependencyExecuteAction,
+    __out BURN_DEPENDENCY_ACTION* pDependencyRollbackAction
+    );
+
+static HRESULT AddPackageDependencyActions(
+    __in_opt DWORD *pdwInsertSequence,
+    __in const BURN_PACKAGE* pPackage,
+    __in BURN_PLAN* pPlan,
+    __in const BURN_DEPENDENCY_ACTION dependencyExecuteAction,
+    __in const BURN_DEPENDENCY_ACTION dependencyRollbackAction
+    );
+
+static HRESULT RegisterPackageProvider(
+    __in const BURN_PACKAGE* pPackage
+    );
+
+static void UnregisterPackageProvider(
+    __in const BURN_PACKAGE* pPackage
+    );
+
+static HRESULT RegisterPackageDependency(
+    __in BOOL fPerMachine,
+    __in const BURN_PACKAGE* pPackage,
+    __in_z LPCWSTR wzDependentProviderKey
+    );
+
+static void UnregisterPackageDependency(
+    __in BOOL fPerMachine,
+    __in const BURN_PACKAGE* pPackage,
+    __in_z LPCWSTR wzDependentProviderKey
+    );
+
+static BOOL PackageProviderExists(
+    __in const BURN_PACKAGE* pPackage
+    );
+
+
+// functions
+
+extern "C" void DependencyUninitialize(
+    __in BURN_DEPENDENCY_PROVIDER* pProvider
+    )
+{
+    ReleaseStr(pProvider->sczKey);
+    ReleaseStr(pProvider->sczVersion);
+    ReleaseStr(pProvider->sczDisplayName);
+    memset(pProvider, 0, sizeof(BURN_DEPENDENCY_PROVIDER));
+}
+
+extern "C" HRESULT DependencyParseProvidersFromXml(
+    __in BURN_PACKAGE* pPackage,
+    __in IXMLDOMNode* pixnPackage
+    )
+{
+    HRESULT hr = S_OK;
+    IXMLDOMNodeList* pixnNodes = NULL;
+    DWORD cNodes = 0;
+    IXMLDOMNode* pixnNode = NULL;
+
+    // Select dependency provider nodes.
+    hr = XmlSelectNodes(pixnPackage, L"Provides", &pixnNodes);
+    ExitOnFailure(hr, "Failed to select dependency provider nodes.");
+
+    // Get dependency provider node count.
+    hr = pixnNodes->get_length((long*)&cNodes);
+    ExitOnFailure(hr, "Failed to get the dependency provider node count.");
+
+    if (!cNodes)
+    {
+        ExitFunction1(hr = S_OK);
+    }
+
+    // Allocate memory for dependency provider pointers.
+    pPackage->rgDependencyProviders = (BURN_DEPENDENCY_PROVIDER*)MemAlloc(sizeof(BURN_DEPENDENCY_PROVIDER) * cNodes, TRUE);
+    ExitOnNull(pPackage->rgDependencyProviders, hr, E_OUTOFMEMORY, "Failed to allocate memory for dependency providers.");
+
+    pPackage->cDependencyProviders = cNodes;
+
+    // Parse dependency provider elements.
+    for (DWORD i = 0; i < cNodes; i++)
+    {
+        BURN_DEPENDENCY_PROVIDER* pDependencyProvider = &pPackage->rgDependencyProviders[i];
+
+        hr = XmlNextElement(pixnNodes, &pixnNode, NULL);
+        ExitOnFailure(hr, "Failed to get the next dependency provider node.");
+
+        // @Key
+        hr = XmlGetAttributeEx(pixnNode, L"Key", &pDependencyProvider->sczKey);
+        ExitOnFailure(hr, "Failed to get the Key attribute.");
+
+        // @Version
+        hr = XmlGetAttributeEx(pixnNode, L"Version", &pDependencyProvider->sczVersion);
+        if (E_NOTFOUND != hr)
+        {
+            ExitOnFailure(hr, "Failed to get the Version attribute.");
+        }
+
+        // @DisplayName
+        hr = XmlGetAttributeEx(pixnNode, L"DisplayName", &pDependencyProvider->sczDisplayName);
+        if (E_NOTFOUND != hr)
+        {
+            ExitOnFailure(hr, "Failed to get the DisplayName attribute.");
+        }
+
+        // @Imported
+        hr = XmlGetYesNoAttribute(pixnNode, L"Imported", &pDependencyProvider->fImported);
+        if (E_NOTFOUND != hr)
+        {
+            ExitOnFailure(hr, "Failed to get the Imported attribute.");
+        }
+        else
+        {
+            pDependencyProvider->fImported = FALSE;
+            hr = S_OK;
+        }
+
+        // Prepare next iteration.
+        ReleaseNullObject(pixnNode);
+    }
+
+    hr = S_OK;
+
+LExit:
+    ReleaseObject(pixnNode);
+    ReleaseObject(pixnNodes);
+
+    return hr;
+}
+
+extern "C" HRESULT DependencyDetectProviderKeyPackageId(
+    __in const BURN_PACKAGE* pPackage,
+    __deref_opt_out_z_opt LPWSTR* psczProviderKey,
+    __deref_opt_out_z_opt LPWSTR* psczId
+    )
+{
+    HRESULT hr = E_NOTFOUND;
+    LPWSTR wzProviderKey = NULL;
+    HKEY hkRoot = pPackage->fPerMachine ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
+
+    for (DWORD i = 0; i < pPackage->cDependencyProviders; ++i)
+    {
+        const BURN_DEPENDENCY_PROVIDER* pProvider = &pPackage->rgDependencyProviders[i];
+
+        // Find the first package id registered for the provider key.
+        hr = GetProviderInformation(hkRoot, pProvider->sczKey, psczProviderKey, psczId);
+        if (E_NOTFOUND == hr)
+        {
+            continue;
+        }
+        ExitOnFailure(hr, "Failed to get the package provider information.");
+
+        ExitFunction();
+    }
+
+    // Older bundles may not have written the id so try the default.
+    if (BURN_PACKAGE_TYPE_MSI == pPackage->type)
+    {
+        wzProviderKey = pPackage->Msi.sczProductCode;
+    }
+
+    if (wzProviderKey)
+    {
+        hr = GetProviderInformation(hkRoot, wzProviderKey, psczProviderKey, psczId);
+        if (E_NOTFOUND == hr)
+        {
+            ExitFunction();
+        }
+        ExitOnFailure(hr, "Failed to get the package default provider information.");
+    }
+
+LExit:
+    return hr;
+}
+
+extern "C" HRESULT DependencyDetectProviderKeyBundleId(
+    __in BURN_REGISTRATION* pRegistration
+    )
+{
+    HRESULT hr = S_OK;
+
+    hr = DepGetProviderInformation(pRegistration->hkRoot, pRegistration->sczProviderKey, &pRegistration->sczDetectedProviderKeyBundleId, NULL, NULL);
+    if (E_NOTFOUND == hr)
+    {
+        ExitFunction();
+    }
+    ExitOnFailure(hr, "Failed to get provider key bundle id.");
+
+    // If a bundle id was not explicitly set, default the provider key bundle id to this bundle's provider key.
+    if (!pRegistration->sczDetectedProviderKeyBundleId || !*pRegistration->sczDetectedProviderKeyBundleId)
+    {
+        hr = StrAllocString(&pRegistration->sczDetectedProviderKeyBundleId, pRegistration->sczProviderKey, 0);
+        ExitOnFailure(hr, "Failed to initialize provider key bundle id.");
+    }
+
+LExit:
+    return hr;
+}
+
+extern "C" HRESULT DependencyPlanInitialize(
+    __in const BURN_ENGINE_STATE* pEngineState,
+    __in BURN_PLAN* pPlan
+    )
+{
+    HRESULT hr = S_OK;
+
+    // The current bundle provider key should always be ignored for dependency checks.
+    hr = DepDependencyArrayAlloc(&pPlan->rgPlannedProviders, &pPlan->cPlannedProviders, pEngineState->registration.sczProviderKey, NULL);
+    ExitOnFailure(hr, "Failed to add the bundle provider key to the list of dependencies to ignore.");
+
+    // Add the list of dependencies to ignore to the plan.
+    if (pEngineState->sczIgnoreDependencies)
+    {
+        // TODO: After adding enumeration to STRINGDICT, a single STRINGDICT_HANDLE can be used everywhere.
+        hr = SplitIgnoreDependencies(pEngineState->sczIgnoreDependencies, &pPlan->rgPlannedProviders, &pPlan->cPlannedProviders);
+        ExitOnFailure(hr, "Failed to split the list of dependencies to ignore.");
+    }
+
+LExit:
+    return hr;
+}
+
+extern "C" HRESULT DependencyAllocIgnoreDependencies(
+    __in const BURN_PLAN *pPlan,
+    __out_z LPWSTR* psczIgnoreDependencies
+    )
+{
+    HRESULT hr = S_OK;
+
+    // Join the list of dependencies to ignore for each related bundle.
+    if (0 < pPlan->cPlannedProviders)
+    {
+        hr = JoinIgnoreDependencies(psczIgnoreDependencies, pPlan->rgPlannedProviders, pPlan->cPlannedProviders);
+        ExitOnFailure(hr, "Failed to join the list of dependencies to ignore.");
+    }
+
+LExit:
+    return hr;
+}
+
+extern "C" HRESULT DependencyAddIgnoreDependencies(
+    __in STRINGDICT_HANDLE sdIgnoreDependencies,
+    __in_z LPCWSTR wzAddIgnoreDependencies
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR wzContext = NULL;
+
+    // Parse through the semicolon-delimited tokens and add to the array.
+    for (LPCWSTR wzToken = ::wcstok_s(const_cast<LPWSTR>(wzAddIgnoreDependencies), vcszIgnoreDependenciesDelim, &wzContext); wzToken; wzToken = ::wcstok_s(NULL, vcszIgnoreDependenciesDelim, &wzContext))
+    {
+        hr = DictKeyExists(sdIgnoreDependencies, wzToken);
+        if (E_NOTFOUND != hr)
+        {
+            ExitOnFailure(hr, "Failed to check the dictionary of unique dependencies.");
+        }
+        else
+        {
+            hr = DictAddKey(sdIgnoreDependencies, wzToken);
+            ExitOnFailure(hr, "Failed to add \"%ls\" to the string dictionary.", wzToken);
+        }
+    }
+
+LExit:
+    return hr;
+}
+
+extern "C" BOOL DependencyDependentExists(
+    __in const BURN_REGISTRATION* pRegistration,
+    __in_z LPCWSTR wzDependentProviderKey
+    )
+{
+    HRESULT hr = S_OK;
+
+    hr = DepDependentExists(pRegistration->hkRoot, pRegistration->sczProviderKey, wzDependentProviderKey);
+    return SUCCEEDED(hr);
+}
+
+extern "C" HRESULT DependencyPlanPackageBegin(
+    __in BOOL fPerMachine,
+    __in BURN_PACKAGE* pPackage,
+    __in BURN_PLAN* pPlan
+    )
+{
+    HRESULT hr = S_OK;
+    STRINGDICT_HANDLE sdIgnoredDependents = NULL;
+    DEPENDENCY* rgDependents = NULL;
+    UINT cDependents = 0;
+    HKEY hkHive = pPackage->fPerMachine ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
+    BURN_DEPENDENCY_ACTION dependencyExecuteAction = BURN_DEPENDENCY_ACTION_NONE;
+    BURN_DEPENDENCY_ACTION dependencyRollbackAction = BURN_DEPENDENCY_ACTION_NONE;
+
+    pPackage->dependencyExecute = BURN_DEPENDENCY_ACTION_NONE;
+    pPackage->dependencyRollback = BURN_DEPENDENCY_ACTION_NONE;
+
+    // Make sure the package defines at least one provider.
+    if (0 == pPackage->cDependencyProviders)
+    {
+        LogId(REPORT_VERBOSE, MSG_DEPENDENCY_PACKAGE_SKIP_NOPROVIDERS, pPackage->sczId);
+        ExitFunction1(hr = S_OK);
+    }
+
+    // Make sure the package is in the same scope as the bundle.
+    if (fPerMachine != pPackage->fPerMachine)
+    {
+        LogId(REPORT_STANDARD, MSG_DEPENDENCY_PACKAGE_SKIP_WRONGSCOPE, pPackage->sczId, LoggingPerMachineToString(fPerMachine), LoggingPerMachineToString(pPackage->fPerMachine));
+        ExitFunction1(hr = S_OK);
+    }
+
+    // If we're uninstalling the package, check if any dependents are registered.
+    if (BOOTSTRAPPER_ACTION_STATE_UNINSTALL == pPackage->execute)
+    {
+        // Build up a list of dependents to ignore, including the current bundle.
+        hr = GetIgnoredDependents(pPackage, pPlan, &sdIgnoredDependents);
+        ExitOnFailure(hr, "Failed to build the list of ignored dependents.");
+
+        // Skip the dependency check if "ALL" was authored for IGNOREDEPENDENCIES.
+        hr = DictKeyExists(sdIgnoredDependents, L"ALL");
+        if (E_NOTFOUND != hr)
+        {
+            ExitOnFailure(hr, "Failed to check if \"ALL\" was set in IGNOREDEPENDENCIES.");
+        }
+        else
+        {
+            for (DWORD i = 0; i < pPackage->cDependencyProviders; ++i)
+            {
+                const BURN_DEPENDENCY_PROVIDER* pProvider = &pPackage->rgDependencyProviders[i];
+
+                hr = DepCheckDependents(hkHive, pProvider->sczKey, 0, sdIgnoredDependents, &rgDependents, &cDependents);
+                if (E_FILENOTFOUND != hr)
+                {
+                    ExitOnFailure(hr, "Failed dependents check on package provider: %ls", pProvider->sczKey);
+                }
+                else
+                {
+                    hr = S_OK;
+                }
+            }
+        }
+    }
+
+    // Calculate the dependency actions before the package itself is planned.
+    CalculateDependencyActionStates(pPackage, pPlan->action, &dependencyExecuteAction, &dependencyRollbackAction);
+
+    // If dependents were found, change the action to not uninstall the package.
+    if (0 < cDependents)
+    {
+        LogId(REPORT_STANDARD, MSG_DEPENDENCY_PACKAGE_HASDEPENDENTS, pPackage->sczId, cDependents);
+
+        for (DWORD i = 0; i < cDependents; ++i)
+        {
+            const DEPENDENCY* pDependency = &rgDependents[i];
+            LogId(REPORT_VERBOSE, MSG_DEPENDENCY_PACKAGE_DEPENDENT, pDependency->sczKey, LoggingStringOrUnknownIfNull(pDependency->sczName));
+        }
+
+        pPackage->fDependencyManagerWasHere = TRUE;
+        pPackage->execute = BOOTSTRAPPER_ACTION_STATE_NONE;
+        pPackage->rollback = BOOTSTRAPPER_ACTION_STATE_NONE;
+    }
+    // Use the calculated dependency actions as the provider actions if there
+    // are any non-imported providers that need to be registered and the package
+    // is current (not obsolete).
+    else if (BOOTSTRAPPER_PACKAGE_STATE_OBSOLETE != pPackage->currentState)
+    {
+        BOOL fAllImportedProviders = TRUE; // assume all providers were imported.
+        for (DWORD i = 0; i < pPackage->cDependencyProviders; ++i)
+        {
+            const BURN_DEPENDENCY_PROVIDER* pProvider = &pPackage->rgDependencyProviders[i];
+            if (!pProvider->fImported)
+            {
+                fAllImportedProviders = FALSE;
+                break;
+            }
+        }
+
+        if (!fAllImportedProviders)
+        {
+            pPackage->providerExecute = dependencyExecuteAction;
+            pPackage->providerRollback = dependencyRollbackAction;
+        }
+    }
+
+    // If the package will be removed, add its providers to the growing list in the plan.
+    if (BOOTSTRAPPER_ACTION_STATE_UNINSTALL == pPackage->execute)
+    {
+        for (DWORD i = 0; i < pPackage->cDependencyProviders; ++i)
+        {
+            const BURN_DEPENDENCY_PROVIDER* pProvider = &pPackage->rgDependencyProviders[i];
+
+            hr = DepDependencyArrayAlloc(&pPlan->rgPlannedProviders, &pPlan->cPlannedProviders, pProvider->sczKey, NULL);
+            ExitOnFailure(hr, "Failed to add the package provider key \"%ls\" to the planned list.", pProvider->sczKey);
+        }
+    }
+
+    pPackage->dependencyExecute = dependencyExecuteAction;
+    pPackage->dependencyRollback = dependencyRollbackAction;
+
+LExit:
+    ReleaseDependencyArray(rgDependents, cDependents);
+    ReleaseDict(sdIgnoredDependents);
+
+    return hr;
+}
+
+extern "C" HRESULT DependencyPlanPackage(
+    __in_opt DWORD *pdwInsertSequence,
+    __in const BURN_PACKAGE* pPackage,
+    __in BURN_PLAN* pPlan
+    )
+{
+    HRESULT hr = S_OK;
+    BURN_EXECUTE_ACTION* pAction = NULL;
+
+    // If the dependency execution action is to unregister, add the dependency actions to the plan
+    // *before* the provider key is potentially removed.
+    if (BURN_DEPENDENCY_ACTION_UNREGISTER == pPackage->dependencyExecute)
+    {
+        hr = AddPackageDependencyActions(pdwInsertSequence, pPackage, pPlan, pPackage->dependencyExecute, pPackage->dependencyRollback);
+        ExitOnFailure(hr, "Failed to plan the dependency actions for package: %ls", pPackage->sczId);
+    }
+
+    // Add the provider rollback plan.
+    if (BURN_DEPENDENCY_ACTION_NONE != pPackage->providerRollback)
+    {
+        hr = PlanAppendRollbackAction(pPlan, &pAction);
+        ExitOnFailure(hr, "Failed to append provider rollback action.");
+
+        pAction->type = BURN_EXECUTE_ACTION_TYPE_PACKAGE_PROVIDER;
+        pAction->packageProvider.pPackage = const_cast<BURN_PACKAGE*>(pPackage);
+        pAction->packageProvider.action = pPackage->providerRollback;
+
+        // Put a checkpoint before the execute action so that rollback happens
+        // if execute fails.
+        hr = PlanExecuteCheckpoint(pPlan);
+        ExitOnFailure(hr, "Failed to plan provider checkpoint action.");
+    }
+
+    // Add the provider execute plan. This comes after rollback so if something goes wrong
+    // rollback will try to clean up after us.
+    if (BURN_DEPENDENCY_ACTION_NONE != pPackage->providerExecute)
+    {
+        if (NULL != pdwInsertSequence)
+        {
+            hr = PlanInsertExecuteAction(*pdwInsertSequence, pPlan, &pAction);
+            ExitOnFailure(hr, "Failed to insert provider execute action.");
+
+            // Always move the sequence after this dependency action so the provider registration
+            // stays in front of the inserted actions.
+            ++(*pdwInsertSequence);
+        }
+        else
+        {
+            hr = PlanAppendExecuteAction(pPlan, &pAction);
+            ExitOnFailure(hr, "Failed to append provider execute action.");
+        }
+
+        pAction->type = BURN_EXECUTE_ACTION_TYPE_PACKAGE_PROVIDER;
+        pAction->packageProvider.pPackage = const_cast<BURN_PACKAGE*>(pPackage);
+        pAction->packageProvider.action = pPackage->providerExecute;
+    }
+
+LExit:
+    return hr;
+}
+
+extern "C" HRESULT DependencyPlanPackageComplete(
+    __in BURN_PACKAGE* pPackage,
+    __in BURN_PLAN* pPlan
+    )
+{
+    HRESULT hr = S_OK;
+
+    // Registration of dependencies happens here, after the package is planned to be
+    // installed and all that good stuff.
+    if (BURN_DEPENDENCY_ACTION_REGISTER == pPackage->dependencyExecute)
+    {
+        // Recalculate the dependency actions in case other operations may have changed
+        // the package execution state.
+        CalculateDependencyActionStates(pPackage, pPlan->action, &pPackage->dependencyExecute, &pPackage->dependencyRollback);
+
+        // If the dependency execution action is *still* to register, add the dependency actions to the plan.
+        if (BURN_DEPENDENCY_ACTION_REGISTER == pPackage->dependencyExecute)
+        {
+            hr = AddPackageDependencyActions(NULL, pPackage, pPlan, pPackage->dependencyExecute, pPackage->dependencyRollback);
+            ExitOnFailure(hr, "Failed to plan the dependency actions for package: %ls", pPackage->sczId);
+        }
+    }
+
+LExit:
+    return hr;
+}
+
+extern "C" HRESULT DependencyExecutePackageProviderAction(
+    __in const BURN_EXECUTE_ACTION* pAction
+    )
+{
+    AssertSz(BURN_EXECUTE_ACTION_TYPE_PACKAGE_PROVIDER == pAction->type, "Execute action type not supported by this function.");
+
+    HRESULT hr = S_OK;
+    const BURN_PACKAGE* pPackage = pAction->packageProvider.pPackage;
+
+    // Register or unregister the package provider(s).
+    if (BURN_DEPENDENCY_ACTION_REGISTER == pAction->packageProvider.action)
+    {
+        hr = RegisterPackageProvider(pPackage);
+        ExitOnFailure(hr, "Failed to register the package providers.");
+    }
+    else if (BURN_DEPENDENCY_ACTION_UNREGISTER == pAction->packageProvider.action)
+    {
+        UnregisterPackageProvider(pPackage);
+    }
+
+LExit:
+    if (!pPackage->fVital)
+    {
+        hr = S_OK;
+    }
+
+    return hr;
+}
+
+extern "C" HRESULT DependencyExecutePackageDependencyAction(
+    __in BOOL fPerMachine,
+    __in const BURN_EXECUTE_ACTION* pAction
+    )
+{
+    AssertSz(BURN_EXECUTE_ACTION_TYPE_PACKAGE_DEPENDENCY == pAction->type, "Execute action type not supported by this function.");
+
+    HRESULT hr = S_OK;
+    const BURN_PACKAGE* pPackage = pAction->packageDependency.pPackage;
+
+    // Register or unregister the bundle as a dependent of each package dependency provider.
+    if (BURN_DEPENDENCY_ACTION_REGISTER == pAction->packageDependency.action)
+    {
+        hr = RegisterPackageDependency(fPerMachine, pPackage, pAction->packageDependency.sczBundleProviderKey);
+        ExitOnFailure(hr, "Failed to register the dependency on the package provider.");
+    }
+    else if (BURN_DEPENDENCY_ACTION_UNREGISTER == pAction->packageDependency.action)
+    {
+        UnregisterPackageDependency(fPerMachine, pPackage, pAction->packageDependency.sczBundleProviderKey);
+    }
+
+LExit:
+    if (!pPackage->fVital)
+    {
+        hr = S_OK;
+    }
+
+    return hr;
+}
+
+extern "C" HRESULT DependencyRegisterBundle(
+    __in const BURN_REGISTRATION* pRegistration
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR sczVersion = NULL;
+
+    hr = FileVersionToStringEx(pRegistration->qwVersion, &sczVersion);
+    ExitOnFailure(hr, "Failed to format the registration version string.");
+
+    LogId(REPORT_VERBOSE, MSG_DEPENDENCY_BUNDLE_REGISTER, pRegistration->sczProviderKey, sczVersion);
+
+    // Register the bundle provider key.
+    hr = DepRegisterDependency(pRegistration->hkRoot, pRegistration->sczProviderKey, sczVersion, pRegistration->sczDisplayName, pRegistration->sczId, 0);
+    ExitOnFailure(hr, "Failed to register the bundle dependency provider.");
+
+LExit:
+    ReleaseStr(sczVersion);
+
+    return hr;
+}
+
+extern "C" HRESULT DependencyProcessDependentRegistration(
+    __in const BURN_REGISTRATION* pRegistration,
+    __in const BURN_DEPENDENT_REGISTRATION_ACTION* pAction
+    )
+{
+    HRESULT hr = S_OK;
+
+    switch (pAction->type)
+    {
+    case BURN_DEPENDENT_REGISTRATION_ACTION_TYPE_REGISTER:
+        hr = DepRegisterDependent(pRegistration->hkRoot, pRegistration->sczProviderKey, pAction->sczDependentProviderKey, NULL, NULL, 0);
+        ExitOnFailure(hr, "Failed to register dependent: %ls", pAction->sczDependentProviderKey);
+        break;
+
+    case BURN_DEPENDENT_REGISTRATION_ACTION_TYPE_UNREGISTER:
+        hr = DepUnregisterDependent(pRegistration->hkRoot, pRegistration->sczProviderKey, pAction->sczDependentProviderKey);
+        ExitOnFailure(hr, "Failed to unregister dependent: %ls", pAction->sczDependentProviderKey);
+        break;
+
+    default:
+        hr = E_INVALIDARG;
+        ExitOnRootFailure(hr, "Unrecognized registration action type: %d", pAction->type);
+    }
+
+LExit:
+    return hr;
+}
+
+extern "C" void DependencyUnregisterBundle(
+    __in const BURN_REGISTRATION* pRegistration
+    )
+{
+    HRESULT hr = S_OK;
+
+    // Remove the bundle provider key.
+    hr = DepUnregisterDependency(pRegistration->hkRoot, pRegistration->sczProviderKey);
+    if (SUCCEEDED(hr))
+    {
+        LogId(REPORT_VERBOSE, MSG_DEPENDENCY_BUNDLE_UNREGISTERED, pRegistration->sczProviderKey);
+    }
+    else if (FAILED(hr) && E_FILENOTFOUND != hr)
+    {
+        LogId(REPORT_VERBOSE, MSG_DEPENDENCY_BUNDLE_UNREGISTERED_FAILED, pRegistration->sczProviderKey, hr);
+    }
+}
+
+// internal functions
+
+/********************************************************************
+ SplitIgnoreDependencies - Splits a semicolon-delimited
+  string into a list of unique dependencies to ignore.
+
+*********************************************************************/
+static HRESULT SplitIgnoreDependencies(
+    __in_z LPCWSTR wzIgnoreDependencies,
+    __deref_inout_ecount_opt(*pcDependencies) DEPENDENCY** prgDependencies,
+    __inout LPUINT pcDependencies
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR wzContext = NULL;
+    STRINGDICT_HANDLE sdIgnoreDependencies = NULL;
+
+    // Create a dictionary to hold unique dependencies.
+    hr = DictCreateStringList(&sdIgnoreDependencies, INITIAL_STRINGDICT_SIZE, DICT_FLAG_CASEINSENSITIVE);
+    ExitOnFailure(hr, "Failed to create the string dictionary.");
+
+    // Parse through the semicolon-delimited tokens and add to the array.
+    for (LPCWSTR wzToken = ::wcstok_s(const_cast<LPWSTR>(wzIgnoreDependencies), vcszIgnoreDependenciesDelim, &wzContext); wzToken; wzToken = ::wcstok_s(NULL, vcszIgnoreDependenciesDelim, &wzContext))
+    {
+        hr = DictKeyExists(sdIgnoreDependencies, wzToken);
+        if (E_NOTFOUND != hr)
+        {
+            ExitOnFailure(hr, "Failed to check the dictionary of unique dependencies.");
+        }
+        else
+        {
+            hr = DepDependencyArrayAlloc(prgDependencies, pcDependencies, wzToken, NULL);
+            ExitOnFailure(hr, "Failed to add \"%ls\" to the list of dependencies to ignore.", wzToken);
+
+            hr = DictAddKey(sdIgnoreDependencies, wzToken);
+            ExitOnFailure(hr, "Failed to add \"%ls\" to the string dictionary.", wzToken);
+        }
+    }
+
+LExit:
+    ReleaseDict(sdIgnoreDependencies);
+
+    return hr;
+}
+
+/********************************************************************
+ JoinIgnoreDependencies - Joins a list of dependencies
+  to ignore into a semicolon-delimited string of unique values.
+
+*********************************************************************/
+static HRESULT JoinIgnoreDependencies(
+    __out_z LPWSTR* psczIgnoreDependencies,
+    __in_ecount(cDependencies) const DEPENDENCY* rgDependencies,
+    __in UINT cDependencies
+    )
+{
+    HRESULT hr = S_OK;
+    STRINGDICT_HANDLE sdIgnoreDependencies = NULL;
+
+    // Make sure we pass back an empty string if there are no dependencies.
+    if (0 == cDependencies)
+    {
+        ExitFunction1(hr = S_OK);
+    }
+
+    // Create a dictionary to hold unique dependencies.
+    hr = DictCreateStringList(&sdIgnoreDependencies, INITIAL_STRINGDICT_SIZE, DICT_FLAG_CASEINSENSITIVE);
+    ExitOnFailure(hr, "Failed to create the string dictionary.");
+
+    for (UINT i = 0; i < cDependencies; ++i)
+    {
+        const DEPENDENCY* pDependency = &rgDependencies[i];
+
+        hr = DictKeyExists(sdIgnoreDependencies, pDependency->sczKey);
+        if (E_NOTFOUND != hr)
+        {
+            ExitOnFailure(hr, "Failed to check the dictionary of unique dependencies.");
+        }
+        else
+        {
+            if (0 < i)
+            {
+                hr = StrAllocConcat(psczIgnoreDependencies, vcszIgnoreDependenciesDelim, 1);
+                ExitOnFailure(hr, "Failed to append the string delimiter.");
+            }
+
+            hr = StrAllocConcat(psczIgnoreDependencies, pDependency->sczKey, 0);
+            ExitOnFailure(hr, "Failed to append the key \"%ls\".", pDependency->sczKey);
+
+            hr = DictAddKey(sdIgnoreDependencies, pDependency->sczKey);
+            ExitOnFailure(hr, "Failed to add \"%ls\" to the string dictionary.", pDependency->sczKey);
+        }
+    }
+
+LExit:
+    ReleaseDict(sdIgnoreDependencies);
+
+    return hr;
+}
+
+/********************************************************************
+ GetIgnoredDependents - Combines the current bundle's
+  provider key, packages' provider keys that are being uninstalled,
+  and any ignored dependencies authored for packages into a string
+  list to pass to deputil.
+
+*********************************************************************/
+static HRESULT GetIgnoredDependents(
+    __in const BURN_PACKAGE* pPackage,
+    __in const BURN_PLAN* pPlan,
+    __deref_inout STRINGDICT_HANDLE* psdIgnoredDependents
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR sczIgnoreDependencies = NULL;
+
+    // Create the dictionary and add the bundle provider key initially.
+    hr = DictCreateStringList(psdIgnoredDependents, INITIAL_STRINGDICT_SIZE, DICT_FLAG_CASEINSENSITIVE);
+    ExitOnFailure(hr, "Failed to create the string dictionary.");
+
+    hr = DictAddKey(*psdIgnoredDependents, pPlan->wzBundleProviderKey);
+    ExitOnFailure(hr, "Failed to add the bundle provider key \"%ls\" to the list of ignored dependencies.", pPlan->wzBundleProviderKey);
+
+    // Add previously planned package providers to the dictionary.
+    for (DWORD i = 0; i < pPlan->cPlannedProviders; ++i)
+    {
+        const DEPENDENCY* pDependency = &pPlan->rgPlannedProviders[i];
+
+        hr = DictAddKey(*psdIgnoredDependents, pDependency->sczKey);
+        ExitOnFailure(hr, "Failed to add the package provider key \"%ls\" to the list of ignored dependencies.", pDependency->sczKey);
+    }
+
+    // Get the IGNOREDEPENDENCIES property if defined.
+    hr = PackageGetProperty(pPackage, DEPENDENCY_IGNOREDEPENDENCIES, &sczIgnoreDependencies);
+    if (E_NOTFOUND != hr)
+    {
+        ExitOnFailure(hr, "Failed to get the package property: %ls", DEPENDENCY_IGNOREDEPENDENCIES);
+
+        hr = DependencyAddIgnoreDependencies(*psdIgnoredDependents, sczIgnoreDependencies);
+        ExitOnFailure(hr, "Failed to add the authored ignored dependencies to the cumulative list of ignored dependencies.");
+    }
+    else
+    {
+        hr = S_OK;
+    }
+
+LExit:
+    ReleaseStr(sczIgnoreDependencies);
+
+    return hr;
+}
+
+/********************************************************************
+ GetProviderId - Gets the ID of the package given the provider key.
+
+*********************************************************************/
+static HRESULT GetProviderInformation(
+    __in HKEY hkRoot,
+    __in_z LPCWSTR wzProviderKey,
+    __deref_opt_out_z_opt LPWSTR* psczProviderKey,
+    __deref_opt_out_z_opt LPWSTR* psczId
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR sczId = NULL;
+
+    hr = DepGetProviderInformation(hkRoot, wzProviderKey, &sczId, NULL, NULL);
+    if (E_NOTFOUND == hr)
+    {
+        ExitFunction();
+    }
+    ExitOnFailure(hr, "Failed to get the provider key package id.");
+
+    // If the id was registered return it and exit.
+    if (sczId && *sczId)
+    {
+        if (psczProviderKey)
+        {
+            hr = StrAllocString(psczProviderKey, wzProviderKey, 0);
+            ExitOnFailure(hr, "Failed to copy the provider key.");
+        }
+
+        if (psczId)
+        {
+            *psczId = sczId;
+            sczId = NULL;
+        }
+
+        ExitFunction();
+    }
+    else
+    {
+        hr = E_NOTFOUND;
+    }
+
+LExit:
+    ReleaseStr(sczId);
+
+    return hr;
+}
+
+/********************************************************************
+ CalculateDependencyActionStates - Calculates the dependency execute and
+  rollback actions for a package.
+
+*********************************************************************/
+static void CalculateDependencyActionStates(
+    __in const BURN_PACKAGE* pPackage,
+    __in const BOOTSTRAPPER_ACTION action,
+    __out BURN_DEPENDENCY_ACTION* pDependencyExecuteAction,
+    __out BURN_DEPENDENCY_ACTION* pDependencyRollbackAction
+    )
+{
+    switch (action)
+    {
+    case BOOTSTRAPPER_ACTION_UNINSTALL:
+        // Always remove the dependency when uninstalling a bundle even if the package is absent.
+        *pDependencyExecuteAction = BURN_DEPENDENCY_ACTION_UNREGISTER;
+        break;
+    case BOOTSTRAPPER_ACTION_INSTALL: __fallthrough;
+    case BOOTSTRAPPER_ACTION_CACHE:
+        // Always remove the dependency during rollback when installing a bundle.
+        *pDependencyRollbackAction = BURN_DEPENDENCY_ACTION_UNREGISTER;
+        __fallthrough;
+    case BOOTSTRAPPER_ACTION_MODIFY: __fallthrough;
+    case BOOTSTRAPPER_ACTION_REPAIR:
+        switch (pPackage->execute)
+        {
+        case BOOTSTRAPPER_ACTION_STATE_NONE:
+            switch (pPackage->requested)
+            {
+            case BOOTSTRAPPER_REQUEST_STATE_NONE:
+                // Register if a newer, compatible package is already installed.
+                switch (pPackage->currentState)
+                {
+                case BOOTSTRAPPER_PACKAGE_STATE_OBSOLETE:
+                    if (!PackageProviderExists(pPackage))
+                    {
+                        break;
+                    }
+                    __fallthrough;
+                case BOOTSTRAPPER_PACKAGE_STATE_SUPERSEDED:
+                    *pDependencyExecuteAction = BURN_DEPENDENCY_ACTION_REGISTER;
+                    break;
+                }
+                break;
+            case BOOTSTRAPPER_REQUEST_STATE_PRESENT: __fallthrough;
+            case BOOTSTRAPPER_REQUEST_STATE_REPAIR:
+                // Register if the package is requested but already installed.
+                switch (pPackage->currentState)
+                {
+                case BOOTSTRAPPER_PACKAGE_STATE_OBSOLETE:
+                    if (!PackageProviderExists(pPackage))
+                    {
+                        break;
+                    }
+                    __fallthrough;
+                case BOOTSTRAPPER_PACKAGE_STATE_PRESENT: __fallthrough;
+                case BOOTSTRAPPER_PACKAGE_STATE_SUPERSEDED:
+                    *pDependencyExecuteAction = BURN_DEPENDENCY_ACTION_REGISTER;
+                    break;
+                }
+                break;
+            }
+            break;
+        case BOOTSTRAPPER_ACTION_STATE_UNINSTALL:
+            *pDependencyExecuteAction = BURN_DEPENDENCY_ACTION_UNREGISTER;
+            break;
+        case BOOTSTRAPPER_ACTION_STATE_INSTALL: __fallthrough;
+        case BOOTSTRAPPER_ACTION_STATE_MODIFY: __fallthrough;
+        case BOOTSTRAPPER_ACTION_STATE_REPAIR: __fallthrough;
+        case BOOTSTRAPPER_ACTION_STATE_MINOR_UPGRADE: __fallthrough;
+        case BOOTSTRAPPER_ACTION_STATE_MAJOR_UPGRADE: __fallthrough;
+        case BOOTSTRAPPER_ACTION_STATE_PATCH:
+            *pDependencyExecuteAction = BURN_DEPENDENCY_ACTION_REGISTER;
+            break;
+        }
+        break;
+    }
+
+    switch (*pDependencyExecuteAction)
+    {
+    case BURN_DEPENDENCY_ACTION_REGISTER:
+        switch (pPackage->currentState)
+        {
+        case BOOTSTRAPPER_PACKAGE_STATE_OBSOLETE: __fallthrough;
+        case BOOTSTRAPPER_PACKAGE_STATE_ABSENT: __fallthrough;
+        case BOOTSTRAPPER_PACKAGE_STATE_CACHED:
+            *pDependencyRollbackAction = BURN_DEPENDENCY_ACTION_UNREGISTER;
+            break;
+        }
+        break;
+    case BURN_DEPENDENCY_ACTION_UNREGISTER:
+        switch (pPackage->currentState)
+        {
+        case BOOTSTRAPPER_PACKAGE_STATE_PRESENT: __fallthrough;
+        case BOOTSTRAPPER_PACKAGE_STATE_SUPERSEDED:
+            *pDependencyRollbackAction = BURN_DEPENDENCY_ACTION_REGISTER;
+            break;
+        }
+        break;
+    }
+}
+
+/********************************************************************
+ AddPackageDependencyActions - Adds the dependency execute and rollback
+  actions to the plan.
+
+*********************************************************************/
+static HRESULT AddPackageDependencyActions(
+    __in_opt DWORD *pdwInsertSequence,
+    __in const BURN_PACKAGE* pPackage,
+    __in BURN_PLAN* pPlan,
+    __in const BURN_DEPENDENCY_ACTION dependencyExecuteAction,
+    __in const BURN_DEPENDENCY_ACTION dependencyRollbackAction
+    )
+{
+    HRESULT hr = S_OK;
+    BURN_EXECUTE_ACTION* pAction = NULL;
+
+    // Add the rollback plan.
+    if (BURN_DEPENDENCY_ACTION_NONE != dependencyRollbackAction)
+    {
+        hr = PlanAppendRollbackAction(pPlan, &pAction);
+        ExitOnFailure(hr, "Failed to append rollback action.");
+
+        pAction->type = BURN_EXECUTE_ACTION_TYPE_PACKAGE_DEPENDENCY;
+        pAction->packageDependency.pPackage = const_cast<BURN_PACKAGE*>(pPackage);
+        pAction->packageDependency.action = dependencyRollbackAction;
+
+        hr = StrAllocString(&pAction->packageDependency.sczBundleProviderKey, pPlan->wzBundleProviderKey, 0);
+        ExitOnFailure(hr, "Failed to copy the bundle dependency provider.");
+
+        // Put a checkpoint before the execute action so that rollback happens
+        // if execute fails.
+        hr = PlanExecuteCheckpoint(pPlan);
+        ExitOnFailure(hr, "Failed to plan dependency checkpoint action.");
+    }
+
+    // Add the execute plan. This comes after rollback so if something goes wrong
+    // rollback will try to clean up after us correctly.
+    if (BURN_DEPENDENCY_ACTION_NONE != dependencyExecuteAction)
+    {
+        if (NULL != pdwInsertSequence)
+        {
+            hr = PlanInsertExecuteAction(*pdwInsertSequence, pPlan, &pAction);
+            ExitOnFailure(hr, "Failed to insert execute action.");
+
+            // Always move the sequence after this dependency action so the dependency registration
+            // stays in front of the inserted actions.
+            ++(*pdwInsertSequence);
+        }
+        else
+        {
+            hr = PlanAppendExecuteAction(pPlan, &pAction);
+            ExitOnFailure(hr, "Failed to append execute action.");
+        }
+
+        pAction->type = BURN_EXECUTE_ACTION_TYPE_PACKAGE_DEPENDENCY;
+        pAction->packageDependency.pPackage = const_cast<BURN_PACKAGE*>(pPackage);
+        pAction->packageDependency.action = dependencyExecuteAction;
+
+        hr = StrAllocString(&pAction->packageDependency.sczBundleProviderKey, pPlan->wzBundleProviderKey, 0);
+        ExitOnFailure(hr, "Failed to copy the bundle dependency provider.");
+    }
+
+LExit:
+    return hr;
+}
+
+static HRESULT RegisterPackageProvider(
+    __in const BURN_PACKAGE* pPackage
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR wzId = NULL;
+    HKEY hkRoot = pPackage->fPerMachine ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
+
+    if (pPackage->rgDependencyProviders)
+    {
+        if (BURN_PACKAGE_TYPE_MSI == pPackage->type)
+        {
+            wzId = pPackage->Msi.sczProductCode;
+        }
+        else if (BURN_PACKAGE_TYPE_MSP == pPackage->type)
+        {
+            wzId = pPackage->Msp.sczPatchCode;
+        }
+
+        for (DWORD i = 0; i < pPackage->cDependencyProviders; ++i)
+        {
+            const BURN_DEPENDENCY_PROVIDER* pProvider = &pPackage->rgDependencyProviders[i];
+
+            if (!pProvider->fImported)
+            {
+                LogId(REPORT_VERBOSE, MSG_DEPENDENCY_PACKAGE_REGISTER, pProvider->sczKey, pProvider->sczVersion, pPackage->sczId);
+
+                hr = DepRegisterDependency(hkRoot, pProvider->sczKey, pProvider->sczVersion, pProvider->sczDisplayName, wzId, 0);
+                ExitOnFailure(hr, "Failed to register the package dependency provider: %ls", pProvider->sczKey);
+            }
+        }
+    }
+
+LExit:
+    if (!pPackage->fVital)
+    {
+        hr = S_OK;
+    }
+
+    return hr;
+}
+
+/********************************************************************
+ UnregisterPackageProvider - Removes each dependency provider
+  for the package (if not imported from the package itself).
+
+ Note: Does not check for existing dependents before removing the key.
+*********************************************************************/
+static void UnregisterPackageProvider(
+    __in const BURN_PACKAGE* pPackage
+    )
+{
+    HRESULT hr = S_OK;
+    HKEY hkRoot = pPackage->fPerMachine ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
+
+    if (pPackage->rgDependencyProviders)
+    {
+        for (DWORD i = 0; i < pPackage->cDependencyProviders; ++i)
+        {
+            const BURN_DEPENDENCY_PROVIDER* pProvider = &pPackage->rgDependencyProviders[i];
+
+            if (!pProvider->fImported)
+            {
+                hr = DepUnregisterDependency(hkRoot, pProvider->sczKey);
+                if (SUCCEEDED(hr))
+                {
+                    LogId(REPORT_VERBOSE, MSG_DEPENDENCY_PACKAGE_UNREGISTERED, pProvider->sczKey, pPackage->sczId);
+                }
+                else if (FAILED(hr) && E_FILENOTFOUND != hr)
+                {
+                    LogId(REPORT_VERBOSE, MSG_DEPENDENCY_PACKAGE_UNREGISTERED_FAILED, pProvider->sczKey, pPackage->sczId, hr);
+                }
+            }
+        }
+    }
+}
+
+/********************************************************************
+ RegisterPackageDependency - Registers the provider key
+  as a dependent of a package.
+
+*********************************************************************/
+static HRESULT RegisterPackageDependency(
+    __in BOOL fPerMachine,
+    __in const BURN_PACKAGE* pPackage,
+    __in_z LPCWSTR wzDependentProviderKey
+    )
+{
+    HRESULT hr = S_OK;
+    HKEY hkRoot = fPerMachine ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
+
+    // Do not register a dependency on a package in a different install context.
+    if (fPerMachine != pPackage->fPerMachine)
+    {
+        LogId(REPORT_STANDARD, MSG_DEPENDENCY_PACKAGE_SKIP_WRONGSCOPE, pPackage->sczId, LoggingPerMachineToString(fPerMachine), LoggingPerMachineToString(pPackage->fPerMachine));
+        ExitFunction1(hr = S_OK);
+    }
+
+    if (pPackage->rgDependencyProviders)
+    {
+        for (DWORD i = 0; i < pPackage->cDependencyProviders; ++i)
+        {
+            const BURN_DEPENDENCY_PROVIDER* pProvider = &pPackage->rgDependencyProviders[i];
+
+            LogId(REPORT_VERBOSE, MSG_DEPENDENCY_PACKAGE_REGISTER_DEPENDENCY, wzDependentProviderKey, pProvider->sczKey, pPackage->sczId);
+
+            hr = DepRegisterDependent(hkRoot, pProvider->sczKey, wzDependentProviderKey, NULL, NULL, 0);
+            if (E_FILENOTFOUND != hr || pPackage->fVital)
+            {
+                ExitOnFailure(hr, "Failed to register the dependency on package dependency provider: %ls", pProvider->sczKey);
+            }
+            else
+            {
+                LogId(REPORT_VERBOSE, MSG_DEPENDENCY_PACKAGE_SKIP_MISSING, pProvider->sczKey, pPackage->sczId);
+                hr = S_OK;
+            }
+        }
+    }
+
+LExit:
+    return hr;
+}
+
+/********************************************************************
+ UnregisterPackageDependency - Unregisters the provider key
+  as a dependent of a package.
+
+*********************************************************************/
+static void UnregisterPackageDependency(
+    __in BOOL fPerMachine,
+    __in const BURN_PACKAGE* pPackage,
+    __in_z LPCWSTR wzDependentProviderKey
+    )
+{
+    HRESULT hr = S_OK;
+    HKEY hkRoot = fPerMachine ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
+
+    // Should be no registration to remove since we don't write keys across contexts.
+    if (fPerMachine != pPackage->fPerMachine)
+    {
+        LogId(REPORT_STANDARD, MSG_DEPENDENCY_PACKAGE_SKIP_WRONGSCOPE, pPackage->sczId, LoggingPerMachineToString(fPerMachine), LoggingPerMachineToString(pPackage->fPerMachine));
+        return;
+    }
+
+    // Loop through each package provider and remove the bundle dependency key.
+    if (pPackage->rgDependencyProviders)
+    {
+        for (DWORD i = 0; i < pPackage->cDependencyProviders; ++i)
+        {
+            const BURN_DEPENDENCY_PROVIDER* pProvider = &pPackage->rgDependencyProviders[i];
+
+            hr = DepUnregisterDependent(hkRoot, pProvider->sczKey, wzDependentProviderKey);
+            if (SUCCEEDED(hr))
+            {
+                LogId(REPORT_VERBOSE, MSG_DEPENDENCY_PACKAGE_UNREGISTERED_DEPENDENCY, wzDependentProviderKey, pProvider->sczKey, pPackage->sczId);
+            }
+            else if (FAILED(hr) && E_FILENOTFOUND != hr)
+            {
+                LogId(REPORT_VERBOSE, MSG_DEPENDENCY_PACKAGE_UNREGISTERED_DEPENDENCY_FAILED, wzDependentProviderKey, pProvider->sczKey, pPackage->sczId, hr);
+            }
+        }
+    }
+}
+
+/********************************************************************
+ PackageProviderExists - Checks if a package provider is registered.
+
+*********************************************************************/
+static BOOL PackageProviderExists(
+    __in const BURN_PACKAGE* pPackage
+    )
+{
+    HRESULT hr = DependencyDetectProviderKeyPackageId(pPackage, NULL, NULL);
+    return SUCCEEDED(hr);
+}
diff --git a/src/engine/dependency.h b/src/engine/dependency.h
new file mode 100644
index 00000000..905857e0
--- /dev/null
+++ b/src/engine/dependency.h
@@ -0,0 +1,176 @@
+#pragma once
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+// constants
+
+const LPCWSTR DEPENDENCY_IGNOREDEPENDENCIES = L"IGNOREDEPENDENCIES";
+
+
+// function declarations
+
+/********************************************************************
+ DependencyUninitialize - Frees and zeros memory allocated in the
+  dependency.
+
+*********************************************************************/
+void DependencyUninitialize(
+    __in BURN_DEPENDENCY_PROVIDER* pProvider
+    );
+
+/********************************************************************
+ DependencyParseProvidersFromXml - Parses dependency information
+  from the manifest for the specified package.
+
+*********************************************************************/
+HRESULT DependencyParseProvidersFromXml(
+    __in BURN_PACKAGE* pPackage,
+    __in IXMLDOMNode* pixnPackage
+    );
+
+/********************************************************************
+ DependencyDetectProviderKeyPackageId - Detect if the provider key is
+  registered and if so what package code is registered.
+
+ Note: Returns E_NOTFOUND if the provider key is not registered.
+*********************************************************************/
+HRESULT DependencyDetectProviderKeyPackageId(
+    __in const BURN_PACKAGE* pPackage,
+    __deref_opt_out_z_opt LPWSTR* psczProviderKey,
+    __deref_opt_out_z_opt LPWSTR* psczId
+    );
+
+/********************************************************************
+ DependencyDetectProviderKeyBundleId - Detect if the provider key is
+  registered and if so what bundle is registered.
+
+ Note: Returns E_NOTFOUND if the provider key is not registered.
+*********************************************************************/
+HRESULT DependencyDetectProviderKeyBundleId(
+    __in BURN_REGISTRATION* pRegistration
+    );
+
+/********************************************************************
+ DependencyPlanInitialize - Initializes the plan.
+
+*********************************************************************/
+HRESULT DependencyPlanInitialize(
+    __in const BURN_ENGINE_STATE* pEngineState,
+    __in BURN_PLAN* pPlan
+    );
+
+/********************************************************************
+ DependencyAllocIgnoreDependencies - Allocates the dependencies to
+  ignore as a semicolon-delimited string.
+
+*********************************************************************/
+HRESULT DependencyAllocIgnoreDependencies(
+    __in const BURN_PLAN *pPlan,
+    __out_z LPWSTR* psczIgnoreDependencies
+    );
+
+/********************************************************************
+ DependencyAddIgnoreDependencies - Populates the ignore dependency
+  names.
+
+*********************************************************************/
+HRESULT DependencyAddIgnoreDependencies(
+    __in STRINGDICT_HANDLE sdIgnoreDependencies,
+    __in_z LPCWSTR wzAddIgnoreDependencies
+    );
+
+/********************************************************************
+ DependencyDependentExists - Checks to see if the provider key is
+  already dependent on this bundle.
+
+*********************************************************************/
+BOOL DependencyDependentExists(
+    __in const BURN_REGISTRATION* pRegistration,
+    __in_z LPCWSTR wzDependentProviderKey
+    );
+
+/********************************************************************
+ DependencyPlanPackageBegin - Updates the dependency registration
+  action depending on the calculated state for the package.
+
+*********************************************************************/
+HRESULT DependencyPlanPackageBegin(
+    __in BOOL fPerMachine,
+    __in BURN_PACKAGE* pPackage,
+    __in BURN_PLAN* pPlan
+    );
+
+/********************************************************************
+ DependencyPlanPackage - adds dependency related actions to the plan
+  for this package.
+
+*********************************************************************/
+HRESULT DependencyPlanPackage(
+    __in_opt DWORD *pdwInsertSequence,
+    __in const BURN_PACKAGE* pPackage,
+    __in BURN_PLAN* pPlan
+    );
+
+/********************************************************************
+ DependencyPlanPackageComplete - Updates the dependency registration
+  action depending on the planned action for the package.
+
+*********************************************************************/
+HRESULT DependencyPlanPackageComplete(
+    __in BURN_PACKAGE* pPackage,
+    __in BURN_PLAN* pPlan
+    );
+
+/********************************************************************
+ DependencyExecutePackageProviderAction - Registers or unregisters
+  provider information for the package contained within the action.
+
+*********************************************************************/
+HRESULT DependencyExecutePackageProviderAction(
+    __in const BURN_EXECUTE_ACTION* pAction
+    );
+
+/********************************************************************
+ DependencyExecutePackageDependencyAction - Registers or unregisters
+  dependency information for the package contained within the action.
+
+*********************************************************************/
+HRESULT DependencyExecutePackageDependencyAction(
+    __in BOOL fPerMachine,
+    __in const BURN_EXECUTE_ACTION* pAction
+    );
+
+/********************************************************************
+ DependencyRegisterBundle - Registers the bundle dependency provider.
+
+*********************************************************************/
+HRESULT DependencyRegisterBundle(
+    __in const BURN_REGISTRATION* pRegistration
+    );
+
+/********************************************************************
+ DependencyProcessDependentRegistration - Registers or unregisters dependents
+  on the bundle based on the action.
+
+*********************************************************************/
+HRESULT DependencyProcessDependentRegistration(
+    __in const BURN_REGISTRATION* pRegistration,
+    __in const BURN_DEPENDENT_REGISTRATION_ACTION* pAction
+    );
+
+/********************************************************************
+ DependencyUnregisterBundle - Removes the bundle dependency provider.
+
+ Note: Does not check for existing dependents before removing the key.
+*********************************************************************/
+void DependencyUnregisterBundle(
+    __in const BURN_REGISTRATION* pRegistration
+    );
+
+#if defined(__cplusplus)
+}
+#endif
diff --git a/src/engine/detect.cpp b/src/engine/detect.cpp
new file mode 100644
index 00000000..7953daf5
--- /dev/null
+++ b/src/engine/detect.cpp
@@ -0,0 +1,431 @@
+// 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.
+
+#include "precomp.h"
+
+typedef struct _DETECT_AUTHENTICATION_REQUIRED_DATA
+{
+    BURN_USER_EXPERIENCE* pUX;
+    LPCWSTR wzPackageOrContainerId;
+} DETECT_AUTHENTICATION_REQUIRED_DATA;
+
+// internal function definitions
+static HRESULT AuthenticationRequired(
+    __in LPVOID pData,
+    __in HINTERNET hUrl,
+    __in long lHttpCode,
+    __out BOOL* pfRetrySend,
+    __out BOOL* pfRetry
+    );
+
+static HRESULT DetectAtomFeedUpdate(
+    __in_z LPCWSTR wzBundleId,
+    __in BURN_USER_EXPERIENCE* pUX,
+    __in BURN_UPDATE* pUpdate
+    );
+
+static HRESULT DownloadUpdateFeed(
+    __in_z LPCWSTR wzBundleId,
+    __in BURN_USER_EXPERIENCE* pUX,
+    __in BURN_UPDATE* pUpdate,
+    __deref_inout_z LPWSTR* psczTempFile
+    );
+
+// function definitions
+
+extern "C" void DetectReset(
+    __in BURN_REGISTRATION* pRegistration,
+    __in BURN_PACKAGES* pPackages
+    )
+{
+    RelatedBundlesUninitialize(&pRegistration->relatedBundles);
+    ReleaseNullStr(pRegistration->sczDetectedProviderKeyBundleId);
+    pRegistration->fEnabledForwardCompatibleBundle = FALSE;
+    PackageUninitialize(&pRegistration->forwardCompatibleBundle);
+
+    for (DWORD iPackage = 0; iPackage < pPackages->cPackages; ++iPackage)
+    {
+        BURN_PACKAGE* pPackage = pPackages->rgPackages + iPackage;
+
+        pPackage->currentState = BOOTSTRAPPER_PACKAGE_STATE_UNKNOWN;
+
+        pPackage->cache = BURN_CACHE_STATE_NONE;
+        for (DWORD iPayload = 0; iPayload < pPackage->cPayloads; ++iPayload)
+        {
+            BURN_PACKAGE_PAYLOAD* pPayload = pPackage->rgPayloads + iPayload;
+            pPayload->fCached = FALSE;
+        }
+
+        if (BURN_PACKAGE_TYPE_MSI == pPackage->type)
+        {
+            for (DWORD iFeature = 0; iFeature < pPackage->Msi.cFeatures; ++iFeature)
+            {
+                BURN_MSIFEATURE* pFeature = pPackage->Msi.rgFeatures + iFeature;
+
+                pFeature->currentState = BOOTSTRAPPER_FEATURE_STATE_UNKNOWN;
+            }
+
+            pPackage->Msi.fCompatibleInstalled = FALSE;
+        }
+        else if (BURN_PACKAGE_TYPE_MSP == pPackage->type)
+        {
+            ReleaseNullMem(pPackage->Msp.rgTargetProducts);
+            pPackage->Msp.cTargetProductCodes = 0;
+        }
+    }
+
+    for (DWORD iPatchInfo = 0; iPatchInfo < pPackages->cPatchInfo; ++iPatchInfo)
+    {
+        MSIPATCHSEQUENCEINFOW* pPatchInfo = pPackages->rgPatchInfo + iPatchInfo;
+        pPatchInfo->dwOrder = 0;
+        pPatchInfo->uStatus = 0;
+    }
+}
+
+extern "C" HRESULT DetectForwardCompatibleBundle(
+    __in BURN_USER_EXPERIENCE* pUX,
+    __in BOOTSTRAPPER_COMMAND* pCommand,
+    __in BURN_REGISTRATION* pRegistration
+    )
+{
+    HRESULT hr = S_OK;
+    BOOL fRecommendIgnore = TRUE;
+    BOOL fIgnoreBundle = FALSE;
+
+    if (pRegistration->sczDetectedProviderKeyBundleId &&
+        CSTR_EQUAL != ::CompareStringW(LOCALE_NEUTRAL, NORM_IGNORECASE, pRegistration->sczDetectedProviderKeyBundleId, -1, pRegistration->sczId, -1))
+    {
+        // Only change the recommendation if an active parent was provided.
+        if (pRegistration->sczActiveParent && *pRegistration->sczActiveParent)
+        {
+            // On install, recommend running the forward compatible bundle because there is an active parent. This
+            // will essentially register the parent with the forward compatible bundle.
+            if (BOOTSTRAPPER_ACTION_INSTALL == pCommand->action)
+            {
+                fRecommendIgnore = FALSE;
+            }
+            else if (BOOTSTRAPPER_ACTION_UNINSTALL == pCommand->action ||
+                     BOOTSTRAPPER_ACTION_MODIFY == pCommand->action ||
+                     BOOTSTRAPPER_ACTION_REPAIR == pCommand->action)
+            {
+                // When modifying the bundle, only recommend running the forward compatible bundle if the parent
+                // is already registered as a dependent of the provider key.
+                if (DependencyDependentExists(pRegistration, pRegistration->sczActiveParent))
+                {
+                    fRecommendIgnore = FALSE;
+                }
+            }
+        }
+
+        for (DWORD iRelatedBundle = 0; iRelatedBundle < pRegistration->relatedBundles.cRelatedBundles; ++iRelatedBundle)
+        {
+            BURN_RELATED_BUNDLE* pRelatedBundle = pRegistration->relatedBundles.rgRelatedBundles + iRelatedBundle;
+            fIgnoreBundle = fRecommendIgnore;
+
+            if (BOOTSTRAPPER_RELATION_UPGRADE == pRelatedBundle->relationType &&
+                pRegistration->qwVersion <= pRelatedBundle->qwVersion &&
+                CSTR_EQUAL == ::CompareStringW(LOCALE_NEUTRAL, NORM_IGNORECASE, pRegistration->sczDetectedProviderKeyBundleId, -1, pRelatedBundle->package.sczId, -1))
+            {
+                hr = UserExperienceOnDetectForwardCompatibleBundle(pUX, pRelatedBundle->package.sczId, pRelatedBundle->relationType, pRelatedBundle->sczTag, pRelatedBundle->package.fPerMachine, pRelatedBundle->qwVersion, &fIgnoreBundle);
+                ExitOnRootFailure(hr, "BA aborted detect forward compatible bundle.");
+
+                if (!fIgnoreBundle)
+                {
+                    hr = PseudoBundleInitializePassthrough(&pRegistration->forwardCompatibleBundle, pCommand, NULL, pRegistration->sczActiveParent, pRegistration->sczAncestors, &pRelatedBundle->package);
+                    ExitOnFailure(hr, "Failed to initialize update bundle.");
+
+                    pRegistration->fEnabledForwardCompatibleBundle = TRUE;
+                }
+
+                LogId(REPORT_STANDARD, MSG_DETECTED_FORWARD_COMPATIBLE_BUNDLE, pRelatedBundle->package.sczId, LoggingRelationTypeToString(pRelatedBundle->relationType), LoggingPerMachineToString(pRelatedBundle->package.fPerMachine), LoggingVersionToString(pRelatedBundle->qwVersion), LoggingBoolToString(pRegistration->fEnabledForwardCompatibleBundle));
+                break;
+            }
+        }
+    }
+
+LExit:
+    return hr;
+}
+
+extern "C" HRESULT DetectReportRelatedBundles(
+    __in BURN_USER_EXPERIENCE* pUX,
+    __in BURN_REGISTRATION* pRegistration,
+    __in BOOTSTRAPPER_RELATION_TYPE relationType,
+    __in BOOTSTRAPPER_ACTION action
+    )
+{
+    HRESULT hr = S_OK;
+
+    for (DWORD iRelatedBundle = 0; iRelatedBundle < pRegistration->relatedBundles.cRelatedBundles; ++iRelatedBundle)
+    {
+        const BURN_RELATED_BUNDLE* pRelatedBundle = pRegistration->relatedBundles.rgRelatedBundles + iRelatedBundle;
+        BOOTSTRAPPER_RELATED_OPERATION operation = BOOTSTRAPPER_RELATED_OPERATION_NONE;
+
+        switch (pRelatedBundle->relationType)
+        {
+        case BOOTSTRAPPER_RELATION_UPGRADE:
+            if (BOOTSTRAPPER_RELATION_UPGRADE != relationType && BOOTSTRAPPER_ACTION_UNINSTALL < action)
+            {
+                if (pRegistration->qwVersion > pRelatedBundle->qwVersion)
+                {
+                    operation = BOOTSTRAPPER_RELATED_OPERATION_MAJOR_UPGRADE;
+                }
+                else if (pRegistration->qwVersion < pRelatedBundle->qwVersion)
+                {
+                    operation = BOOTSTRAPPER_RELATED_OPERATION_DOWNGRADE;
+                }
+            }
+            break;
+
+        case BOOTSTRAPPER_RELATION_PATCH: __fallthrough;
+        case BOOTSTRAPPER_RELATION_ADDON:
+            if (BOOTSTRAPPER_ACTION_UNINSTALL == action)
+            {
+                operation = BOOTSTRAPPER_RELATED_OPERATION_REMOVE;
+            }
+            else if (BOOTSTRAPPER_ACTION_INSTALL == action || BOOTSTRAPPER_ACTION_MODIFY == action)
+            {
+                operation = BOOTSTRAPPER_RELATED_OPERATION_INSTALL;
+            }
+            else if (BOOTSTRAPPER_ACTION_REPAIR == action)
+            {
+                operation = BOOTSTRAPPER_RELATED_OPERATION_REPAIR;
+            }
+            break;
+
+        case BOOTSTRAPPER_RELATION_DETECT: __fallthrough;
+        case BOOTSTRAPPER_RELATION_DEPENDENT:
+            break;
+
+        default:
+            hr = E_FAIL;
+            ExitOnRootFailure(hr, "Unexpected relation type encountered: %d", pRelatedBundle->relationType);
+            break;
+        }
+
+        LogId(REPORT_STANDARD, MSG_DETECTED_RELATED_BUNDLE, pRelatedBundle->package.sczId, LoggingRelationTypeToString(pRelatedBundle->relationType), LoggingPerMachineToString(pRelatedBundle->package.fPerMachine), LoggingVersionToString(pRelatedBundle->qwVersion), LoggingRelatedOperationToString(operation));
+
+        hr = UserExperienceOnDetectRelatedBundle(pUX, pRelatedBundle->package.sczId, pRelatedBundle->relationType, pRelatedBundle->sczTag, pRelatedBundle->package.fPerMachine, pRelatedBundle->qwVersion, operation);
+        ExitOnRootFailure(hr, "BA aborted detect related bundle.");
+    }
+
+LExit:
+    return hr;
+}
+
+extern "C" HRESULT DetectUpdate(
+    __in_z LPCWSTR wzBundleId,
+    __in BURN_USER_EXPERIENCE* pUX,
+    __in BURN_UPDATE* pUpdate
+    )
+{
+    HRESULT hr = S_OK;
+    BOOL fBeginCalled = FALSE;
+    BOOL fSkip = TRUE;
+    BOOL fIgnoreError = FALSE;
+
+    // If no update source was specified, skip update detection.
+    if (!pUpdate->sczUpdateSource || !*pUpdate->sczUpdateSource)
+    {
+        ExitFunction();
+    }
+
+    fBeginCalled = TRUE;
+    hr = UserExperienceOnDetectUpdateBegin(pUX, pUpdate->sczUpdateSource, &fSkip);
+    ExitOnRootFailure(hr, "BA aborted detect update begin.");
+
+    if (!fSkip)
+    {
+        hr = DetectAtomFeedUpdate(wzBundleId, pUX, pUpdate);
+        ExitOnFailure(hr, "Failed to detect atom feed update.");
+    }
+
+LExit:
+    if (fBeginCalled)
+    {
+        UserExperienceOnDetectUpdateComplete(pUX, hr, &fIgnoreError);
+        if (fIgnoreError)
+        {
+            hr = S_OK;
+        }
+    }
+
+    return hr;
+}
+
+static HRESULT AuthenticationRequired(
+    __in LPVOID pData,
+    __in HINTERNET hUrl,
+    __in long lHttpCode,
+    __out BOOL* pfRetrySend,
+    __out BOOL* pfRetry
+    )
+{
+    Assert(401 == lHttpCode || 407 == lHttpCode);
+
+    HRESULT hr = S_OK;
+    DWORD er = ERROR_SUCCESS;
+    BOOTSTRAPPER_ERROR_TYPE errorType = (401 == lHttpCode) ? BOOTSTRAPPER_ERROR_TYPE_HTTP_AUTH_SERVER : BOOTSTRAPPER_ERROR_TYPE_HTTP_AUTH_PROXY;
+    LPWSTR sczError = NULL;
+    DETECT_AUTHENTICATION_REQUIRED_DATA* pAuthenticationData = reinterpret_cast<DETECT_AUTHENTICATION_REQUIRED_DATA*>(pData);
+    int nResult = IDNOACTION;
+
+    *pfRetrySend = FALSE;
+    *pfRetry = FALSE;
+
+    hr = StrAllocFromError(&sczError, HRESULT_FROM_WIN32(ERROR_ACCESS_DENIED), NULL);
+    ExitOnFailure(hr, "Failed to allocation error string.");
+
+    UserExperienceOnError(pAuthenticationData->pUX, errorType, pAuthenticationData->wzPackageOrContainerId, ERROR_ACCESS_DENIED, sczError, MB_RETRYTRYAGAIN, 0, NULL, &nResult); // ignore return value.
+    nResult = UserExperienceCheckExecuteResult(pAuthenticationData->pUX, FALSE, MB_RETRYTRYAGAIN, nResult);
+    if (IDTRYAGAIN == nResult && pAuthenticationData->pUX->hwndDetect)
+    {
+        er = ::InternetErrorDlg(pAuthenticationData->pUX->hwndDetect, hUrl, ERROR_INTERNET_INCORRECT_PASSWORD, FLAGS_ERROR_UI_FILTER_FOR_ERRORS | FLAGS_ERROR_UI_FLAGS_CHANGE_OPTIONS | FLAGS_ERROR_UI_FLAGS_GENERATE_DATA, NULL);
+        if (ERROR_SUCCESS == er || ERROR_CANCELLED == er)
+        {
+            hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
+        }
+        else if (ERROR_INTERNET_FORCE_RETRY == er)
+        {
+            *pfRetrySend = TRUE;
+            hr = S_OK;
+        }
+        else
+        {
+            hr = HRESULT_FROM_WIN32(ERROR_ACCESS_DENIED);
+        }
+    }
+    else if (IDRETRY == nResult)
+    {
+        *pfRetry = TRUE;
+        hr = S_OK;
+    }
+    else
+    {
+        hr = HRESULT_FROM_WIN32(ERROR_ACCESS_DENIED);
+    }
+
+LExit:
+    ReleaseStr(sczError);
+
+    return hr;
+}
+
+static HRESULT DownloadUpdateFeed(
+    __in_z LPCWSTR wzBundleId,
+    __in BURN_USER_EXPERIENCE* pUX,
+    __in BURN_UPDATE* pUpdate,
+    __deref_inout_z LPWSTR* psczTempFile
+    )
+{
+    HRESULT hr = S_OK;
+    DOWNLOAD_SOURCE downloadSource = { };
+    DOWNLOAD_CACHE_CALLBACK cacheCallback = { };
+    DOWNLOAD_AUTHENTICATION_CALLBACK authenticationCallback = { };
+    DETECT_AUTHENTICATION_REQUIRED_DATA authenticationData = { };
+    LPWSTR sczUpdateId = NULL;
+    LPWSTR sczError = NULL;
+    DWORD64 qwDownloadSize = 0;
+
+    // Always do our work in the working folder, even if cached.
+    hr = PathCreateTimeBasedTempFile(NULL, L"UpdateFeed", NULL, L"xml", psczTempFile, NULL);
+    ExitOnFailure(hr, "Failed to create UpdateFeed based on current system time.");
+
+    // Do we need a means of the BA to pass in a user name and password? If so, we should copy it to downloadSource here
+    hr = StrAllocString(&downloadSource.sczUrl, pUpdate->sczUpdateSource, 0);
+    ExitOnFailure(hr, "Failed to copy update url.");
+
+    cacheCallback.pfnProgress = NULL; //UpdateProgressRoutine;
+    cacheCallback.pfnCancel = NULL; // TODO: set this
+    cacheCallback.pv = NULL; //pProgress;
+
+    authenticationData.pUX = pUX;
+    authenticationData.wzPackageOrContainerId = wzBundleId;
+
+    authenticationCallback.pv =  static_cast<LPVOID>(&authenticationData);
+    authenticationCallback.pfnAuthenticate = &AuthenticationRequired;
+
+    hr = DownloadUrl(&downloadSource, qwDownloadSize, *psczTempFile, &cacheCallback, &authenticationCallback);
+    ExitOnFailure(hr, "Failed attempt to download update feed from URL: '%ls' to: '%ls'", downloadSource.sczUrl, *psczTempFile);
+
+LExit:
+    if (FAILED(hr))
+    {
+        if (*psczTempFile)
+        {
+            FileEnsureDelete(*psczTempFile);
+        }
+
+        ReleaseNullStr(*psczTempFile);
+    }
+
+    ReleaseStr(downloadSource.sczUrl);
+    ReleaseStr(downloadSource.sczUser);
+    ReleaseStr(downloadSource.sczPassword);
+    ReleaseStr(sczUpdateId);
+    ReleaseStr(sczError);
+    return hr;
+}
+
+
+static HRESULT DetectAtomFeedUpdate(
+    __in_z LPCWSTR wzBundleId,
+    __in BURN_USER_EXPERIENCE* pUX,
+    __in BURN_UPDATE* pUpdate
+    )
+{
+    Assert(pUpdate && pUpdate->sczUpdateSource && *pUpdate->sczUpdateSource);
+#ifdef DEBUG
+    LogStringLine(REPORT_STANDARD, "DetectAtomFeedUpdate() - update location: %ls", pUpdate->sczUpdateSource);
+#endif
+
+
+    HRESULT hr = S_OK;
+    LPWSTR sczUpdateFeedTempFile = NULL;
+    ATOM_FEED* pAtomFeed = NULL;
+    APPLICATION_UPDATE_CHAIN* pApupChain = NULL;
+    BOOL fStopProcessingUpdates = FALSE;
+
+    hr = AtomInitialize();
+    ExitOnFailure(hr, "Failed to initialize Atom.");
+
+    hr = DownloadUpdateFeed(wzBundleId, pUX, pUpdate, &sczUpdateFeedTempFile);
+    ExitOnFailure(hr, "Failed to download update feed.");
+
+    hr = AtomParseFromFile(sczUpdateFeedTempFile, &pAtomFeed);
+    ExitOnFailure(hr, "Failed to parse update atom feed: %ls.", sczUpdateFeedTempFile);
+
+    hr = ApupAllocChainFromAtom(pAtomFeed, &pApupChain);
+    ExitOnFailure(hr, "Failed to allocate update chain from atom feed.");
+
+    if (0 < pApupChain->cEntries)
+    {
+        for (DWORD i = 0; i < pApupChain->cEntries; ++i)
+        {
+            APPLICATION_UPDATE_ENTRY* pAppUpdateEntry = &pApupChain->rgEntries[i];
+
+            hr = UserExperienceOnDetectUpdate(pUX, pAppUpdateEntry->rgEnclosures ? pAppUpdateEntry->rgEnclosures->wzUrl : NULL, 
+                pAppUpdateEntry->rgEnclosures ? pAppUpdateEntry->rgEnclosures->dw64Size : 0, 
+                pAppUpdateEntry->dw64Version, pAppUpdateEntry->wzTitle,
+                pAppUpdateEntry->wzSummary, pAppUpdateEntry->wzContentType, pAppUpdateEntry->wzContent, &fStopProcessingUpdates);
+            ExitOnRootFailure(hr, "BA aborted detect update.");
+
+            if (fStopProcessingUpdates)
+            {
+                break;
+            }
+        }
+    }
+
+LExit:
+    if (sczUpdateFeedTempFile && *sczUpdateFeedTempFile)
+    {
+        FileEnsureDelete(sczUpdateFeedTempFile);
+    }
+
+    ApupFreeChain(pApupChain);
+    AtomFreeFeed(pAtomFeed);
+    ReleaseStr(sczUpdateFeedTempFile);
+    AtomUninitialize();
+
+    return hr;
+}
diff --git a/src/engine/detect.h b/src/engine/detect.h
new file mode 100644
index 00000000..01488f1a
--- /dev/null
+++ b/src/engine/detect.h
@@ -0,0 +1,44 @@
+#pragma once
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+
+// constants
+
+
+// structs
+
+
+// functions
+
+void DetectReset(
+    __in BURN_REGISTRATION* pRegistration,
+    __in BURN_PACKAGES* pPackages
+    );
+
+HRESULT DetectForwardCompatibleBundle(
+    __in BURN_USER_EXPERIENCE* pUX,
+    __in BOOTSTRAPPER_COMMAND* pCommand,
+    __in BURN_REGISTRATION* pRegistration
+    );
+
+HRESULT DetectReportRelatedBundles(
+    __in BURN_USER_EXPERIENCE* pUX,
+    __in BURN_REGISTRATION* pRegistration,
+    __in BOOTSTRAPPER_RELATION_TYPE relationType,
+    __in BOOTSTRAPPER_ACTION action
+    );
+
+HRESULT DetectUpdate(
+    __in_z LPCWSTR wzBundleId,
+    __in BURN_USER_EXPERIENCE* pUX,
+    __in BURN_UPDATE* pUpdate
+    );
+
+#if defined(__cplusplus)
+}
+#endif
diff --git a/src/engine/elevation.cpp b/src/engine/elevation.cpp
new file mode 100644
index 00000000..1b9336e0
--- /dev/null
+++ b/src/engine/elevation.cpp
@@ -0,0 +1,2814 @@
+// 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.
+
+#include "precomp.h"
+
+
+const DWORD BURN_TIMEOUT = 5 * 60 * 1000; // TODO: is 5 minutes good?
+
+typedef enum _BURN_ELEVATION_MESSAGE_TYPE
+{
+    BURN_ELEVATION_MESSAGE_TYPE_UNKNOWN,
+    BURN_ELEVATION_MESSAGE_TYPE_APPLY_INITIALIZE,
+    BURN_ELEVATION_MESSAGE_TYPE_APPLY_UNINITIALIZE,
+    BURN_ELEVATION_MESSAGE_TYPE_SESSION_BEGIN,
+    BURN_ELEVATION_MESSAGE_TYPE_SESSION_RESUME,
+    BURN_ELEVATION_MESSAGE_TYPE_SESSION_END,
+    BURN_ELEVATION_MESSAGE_TYPE_SAVE_STATE,
+    BURN_ELEVATION_MESSAGE_TYPE_LAYOUT_BUNDLE,
+    BURN_ELEVATION_MESSAGE_TYPE_CACHE_OR_LAYOUT_CONTAINER_OR_PAYLOAD,
+    BURN_ELEVATION_MESSAGE_TYPE_CACHE_CLEANUP,
+    BURN_ELEVATION_MESSAGE_TYPE_PROCESS_DEPENDENT_REGISTRATION,
+    BURN_ELEVATION_MESSAGE_TYPE_EXECUTE_EXE_PACKAGE,
+    BURN_ELEVATION_MESSAGE_TYPE_EXECUTE_MSI_PACKAGE,
+    BURN_ELEVATION_MESSAGE_TYPE_EXECUTE_MSP_PACKAGE,
+    BURN_ELEVATION_MESSAGE_TYPE_EXECUTE_MSU_PACKAGE,
+    BURN_ELEVATION_MESSAGE_TYPE_EXECUTE_PACKAGE_PROVIDER,
+    BURN_ELEVATION_MESSAGE_TYPE_EXECUTE_PACKAGE_DEPENDENCY,
+    BURN_ELEVATION_MESSAGE_TYPE_LOAD_COMPATIBLE_PACKAGE,
+    BURN_ELEVATION_MESSAGE_TYPE_LAUNCH_EMBEDDED_CHILD,
+    BURN_ELEVATION_MESSAGE_TYPE_CLEAN_PACKAGE,
+    BURN_ELEVATION_MESSAGE_TYPE_LAUNCH_APPROVED_EXE,
+
+    BURN_ELEVATION_MESSAGE_TYPE_EXECUTE_PROGRESS,
+    BURN_ELEVATION_MESSAGE_TYPE_EXECUTE_ERROR,
+    BURN_ELEVATION_MESSAGE_TYPE_EXECUTE_MSI_MESSAGE,
+    BURN_ELEVATION_MESSAGE_TYPE_EXECUTE_FILES_IN_USE,
+    BURN_ELEVATION_MESSAGE_TYPE_LAUNCH_APPROVED_EXE_PROCESSID,
+
+    BURN_ELEVATION_TRANSACTION_BEGIN,
+    BURN_ELEVATION_TRANSACTION_COMMIT,
+    BURN_ELEVATION_TRANSACTION_ROLLBACK
+
+} BURN_ELEVATION_MESSAGE_TYPE;
+
+
+// struct
+
+typedef struct _BURN_ELEVATION_GENERIC_MESSAGE_CONTEXT
+{
+    PFN_GENERICMESSAGEHANDLER pfnGenericMessageHandler;
+    LPVOID pvContext;
+} BURN_ELEVATION_GENERIC_MESSAGE_CONTEXT;
+
+typedef struct _BURN_ELEVATION_MSI_MESSAGE_CONTEXT
+{
+    PFN_MSIEXECUTEMESSAGEHANDLER pfnMessageHandler;
+    LPVOID pvContext;
+} BURN_ELEVATION_MSI_MESSAGE_CONTEXT;
+
+typedef struct _BURN_ELEVATION_LAUNCH_APPROVED_EXE_MESSAGE_CONTEXT
+{
+    DWORD dwProcessId;
+} BURN_ELEVATION_LAUNCH_APPROVED_EXE_MESSAGE_CONTEXT;
+
+typedef struct _BURN_ELEVATION_CHILD_MESSAGE_CONTEXT
+{
+    DWORD dwLoggingTlsId;
+    HANDLE hPipe;
+    HANDLE* phLock;
+    BOOL* pfDisabledAutomaticUpdates;
+    BURN_APPROVED_EXES* pApprovedExes;
+    BURN_CONTAINERS* pContainers;
+    BURN_PACKAGES* pPackages;
+    BURN_PAYLOADS* pPayloads;
+    BURN_VARIABLES* pVariables;
+    BURN_REGISTRATION* pRegistration;
+    BURN_USER_EXPERIENCE* pUserExperience;
+
+        MSIHANDLE hMsiTrns;
+        HANDLE hMsiTrnsEvent;
+} BURN_ELEVATION_CHILD_MESSAGE_CONTEXT;
+
+
+// internal function declarations
+
+static HRESULT OnMsiBeginTransaction(
+    __in BURN_ELEVATION_CHILD_MESSAGE_CONTEXT* pContext
+);
+static HRESULT OnMsiCommitTransaction(
+    __in BURN_ELEVATION_CHILD_MESSAGE_CONTEXT* pContext
+);
+static HRESULT OnMsiRollbackTransaction(
+    __in BURN_ELEVATION_CHILD_MESSAGE_CONTEXT* pContext
+);
+
+static DWORD WINAPI ElevatedChildCacheThreadProc(
+    __in LPVOID lpThreadParameter
+    );
+static HRESULT WaitForElevatedChildCacheThread(
+    __in HANDLE hCacheThread,
+    __in DWORD dwExpectedExitCode
+    );
+static HRESULT OnLoadCompatiblePackage(
+    __in BURN_PACKAGES* pPackages,
+    __in BYTE* pbData,
+    __in DWORD cbData
+    );
+static HRESULT ProcessGenericExecuteMessages(
+    __in BURN_PIPE_MESSAGE* pMsg,
+    __in_opt LPVOID pvContext,
+    __out DWORD* pdwResult
+    );
+static HRESULT ProcessMsiPackageMessages(
+    __in BURN_PIPE_MESSAGE* pMsg,
+    __in_opt LPVOID pvContext,
+    __out DWORD* pdwResult
+    );
+static HRESULT ProcessLaunchApprovedExeMessages(
+    __in BURN_PIPE_MESSAGE* pMsg,
+    __in_opt LPVOID pvContext,
+    __out DWORD* pdwResult
+    );
+static HRESULT ProcessElevatedChildMessage(
+    __in BURN_PIPE_MESSAGE* pMsg,
+    __in_opt LPVOID pvContext,
+    __out DWORD* pdwResult
+    );
+static HRESULT ProcessElevatedChildCacheMessage(
+    __in BURN_PIPE_MESSAGE* pMsg,
+    __in_opt LPVOID pvContext,
+    __out DWORD* pdwResult
+    );
+static HRESULT ProcessResult(
+    __in DWORD dwResult,
+    __out BOOTSTRAPPER_APPLY_RESTART* pRestart
+    );
+static HRESULT OnApplyInitialize(
+    __in BURN_VARIABLES* pVariables,
+    __in BURN_REGISTRATION* pRegistration,
+    __in HANDLE* phLock,
+    __in BOOL* pfDisabledWindowsUpdate,
+    __in BYTE* pbData,
+    __in DWORD cbData
+    );
+static HRESULT OnApplyUninitialize(
+    __in HANDLE* phLock
+    );
+static HRESULT OnSessionBegin(
+    __in BURN_REGISTRATION* pRegistration,
+    __in BURN_VARIABLES* pVariables,
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in BYTE* pbData,
+    __in DWORD cbData
+    );
+static HRESULT OnSessionResume(
+    __in BURN_REGISTRATION* pRegistration,
+    __in BURN_VARIABLES* pVariables,
+    __in BYTE* pbData,
+    __in DWORD cbData
+    );
+static HRESULT OnSessionEnd(
+    __in BURN_REGISTRATION* pRegistration,
+    __in BYTE* pbData,
+    __in DWORD cbData
+    );
+static HRESULT OnSaveState(
+    __in BURN_REGISTRATION* pRegistration,
+    __in BYTE* pbData,
+    __in DWORD cbData
+    );
+static HRESULT OnLayoutBundle(
+    __in_z LPCWSTR wzExecutableName,
+    __in BYTE* pbData,
+    __in DWORD cbData
+    );
+static HRESULT OnCacheOrLayoutContainerOrPayload(
+    __in BURN_CONTAINERS* pContainers,
+    __in BURN_PACKAGES* pPackages,
+    __in BURN_PAYLOADS* pPayloads,
+    __in BYTE* pbData,
+    __in DWORD cbData
+    );
+static void OnCacheCleanup(
+    __in_z LPCWSTR wzBundleId
+    );
+static HRESULT OnProcessDependentRegistration(
+    __in const BURN_REGISTRATION* pRegistration,
+    __in BYTE* pbData,
+    __in DWORD cbData
+    );
+static HRESULT OnExecuteExePackage(
+    __in HANDLE hPipe,
+    __in BURN_PACKAGES* pPackages,
+    __in BURN_RELATED_BUNDLES* pRelatedBundles,
+    __in BURN_VARIABLES* pVariables,
+    __in BYTE* pbData,
+    __in DWORD cbData
+    );
+static HRESULT OnExecuteMsiPackage(
+    __in HANDLE hPipe,
+    __in BURN_PACKAGES* pPackages,
+    __in BURN_VARIABLES* pVariables,
+    __in BYTE* pbData,
+    __in DWORD cbData
+    );
+static HRESULT OnExecuteMspPackage(
+    __in HANDLE hPipe,
+    __in BURN_PACKAGES* pPackages,
+    __in BURN_VARIABLES* pVariables,
+    __in BYTE* pbData,
+    __in DWORD cbData
+    );
+static HRESULT OnExecuteMsuPackage(
+    __in HANDLE hPipe,
+    __in BURN_PACKAGES* pPackages,
+    __in BURN_VARIABLES* pVariables,
+    __in BYTE* pbData,
+    __in DWORD cbData
+    );
+static HRESULT OnExecutePackageProviderAction(
+    __in BURN_PACKAGES* pPackages,
+    __in BURN_RELATED_BUNDLES* pRelatedBundles,
+    __in BYTE* pbData,
+    __in DWORD cbData
+    );
+static HRESULT OnExecutePackageDependencyAction(
+    __in BURN_PACKAGES* pPackages,
+    __in BURN_RELATED_BUNDLES* pRelatedBundles,
+    __in BYTE* pbData,
+    __in DWORD cbData
+    );
+static int GenericExecuteMessageHandler(
+    __in GENERIC_EXECUTE_MESSAGE* pMessage,
+    __in LPVOID pvContext
+    );
+static int MsiExecuteMessageHandler(
+    __in WIU_MSI_EXECUTE_MESSAGE* pMessage,
+    __in_opt LPVOID pvContext
+    );
+static HRESULT OnCleanPackage(
+    __in BURN_PACKAGES* pPackages,
+    __in BYTE* pbData,
+    __in DWORD cbData
+    );
+static HRESULT OnLaunchApprovedExe(
+    __in HANDLE hPipe,
+    __in BURN_APPROVED_EXES* pApprovedExes,
+    __in BURN_VARIABLES* pVariables,
+    __in BYTE* pbData,
+    __in DWORD cbData
+    );
+
+
+// function definitions
+
+extern "C" HRESULT ElevationElevate(
+    __in BURN_ENGINE_STATE* pEngineState,
+    __in_opt HWND hwndParent
+    )
+{
+    Assert(BURN_MODE_ELEVATED != pEngineState->mode);
+    Assert(!pEngineState->companionConnection.sczName);
+    Assert(!pEngineState->companionConnection.sczSecret);
+    Assert(!pEngineState->companionConnection.hProcess);
+    Assert(!pEngineState->companionConnection.dwProcessId);
+    Assert(INVALID_HANDLE_VALUE == pEngineState->companionConnection.hPipe);
+    Assert(INVALID_HANDLE_VALUE == pEngineState->companionConnection.hCachePipe);
+
+    HRESULT hr = S_OK;
+    int nResult = IDOK;
+    HANDLE hPipesCreatedEvent = INVALID_HANDLE_VALUE;
+
+    hr = UserExperienceOnElevateBegin(&pEngineState->userExperience);
+    ExitOnRootFailure(hr, "BA aborted elevation requirement.");
+
+    hr = PipeCreateNameAndSecret(&pEngineState->companionConnection.sczName, &pEngineState->companionConnection.sczSecret);
+    ExitOnFailure(hr, "Failed to create pipe name and client token.");
+
+    hr = PipeCreatePipes(&pEngineState->companionConnection, TRUE, &hPipesCreatedEvent);
+    ExitOnFailure(hr, "Failed to create pipe and cache pipe.");
+
+    LogId(REPORT_STANDARD, MSG_LAUNCH_ELEVATED_ENGINE_STARTING);
+
+    do
+    {
+        nResult = IDOK;
+
+        // Create the elevated process and if successful, wait for it to connect.
+        hr = PipeLaunchChildProcess(pEngineState->sczBundleEngineWorkingPath, &pEngineState->companionConnection, TRUE, hwndParent);
+        if (SUCCEEDED(hr))
+        {
+            LogId(REPORT_STANDARD, MSG_LAUNCH_ELEVATED_ENGINE_SUCCESS);
+
+            hr = PipeWaitForChildConnect(&pEngineState->companionConnection);
+            ExitOnFailure(hr, "Failed to connect to elevated child process.");
+
+            LogId(REPORT_STANDARD, MSG_CONNECT_TO_ELEVATED_ENGINE_SUCCESS);
+        }
+        else if (HRESULT_FROM_WIN32(ERROR_CANCELLED) == hr)
+        {
+            // The user clicked "Cancel" on the elevation prompt or the elevation prompt timed out, provide the notification with the option to retry.
+            hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
+            nResult = UserExperienceSendError(&pEngineState->userExperience, BOOTSTRAPPER_ERROR_TYPE_ELEVATE, NULL, hr, NULL, MB_ICONERROR | MB_RETRYCANCEL, IDNOACTION);
+        }
+    } while (IDRETRY == nResult);
+    ExitOnFailure(hr, "Failed to elevate.");
+
+LExit:
+    ReleaseHandle(hPipesCreatedEvent);
+
+    if (FAILED(hr))
+    {
+        PipeConnectionUninitialize(&pEngineState->companionConnection);
+    }
+
+    UserExperienceOnElevateComplete(&pEngineState->userExperience, hr);
+
+    return hr;
+}
+
+extern "C" HRESULT ElevationApplyInitialize(
+    __in HANDLE hPipe,
+    __in BURN_VARIABLES* pVariables,
+    __in BOOTSTRAPPER_ACTION action,
+    __in BURN_AU_PAUSE_ACTION auAction,
+    __in BOOL fTakeSystemRestorePoint
+    )
+{
+    HRESULT hr = S_OK;
+    BYTE* pbData = NULL;
+    SIZE_T cbData = 0;
+    DWORD dwResult = 0;
+
+    // serialize message data
+    hr = BuffWriteNumber(&pbData, &cbData, (DWORD)action);
+    ExitOnFailure(hr, "Failed to write action to message buffer.");
+
+    hr = BuffWriteNumber(&pbData, &cbData, (DWORD)auAction);
+    ExitOnFailure(hr, "Failed to write update action to message buffer.");
+
+    hr = BuffWriteNumber(&pbData, &cbData, (DWORD)fTakeSystemRestorePoint);
+    ExitOnFailure(hr, "Failed to write system restore point action to message buffer.");
+    
+    hr = VariableSerialize(pVariables, FALSE, &pbData, &cbData);
+    ExitOnFailure(hr, "Failed to write variables.");
+
+    // send message
+    hr = PipeSendMessage(hPipe, BURN_ELEVATION_MESSAGE_TYPE_APPLY_INITIALIZE, pbData, cbData, NULL, NULL, &dwResult);
+    ExitOnFailure(hr, "Failed to send message to per-machine process.");
+
+    hr = (HRESULT)dwResult;
+
+LExit:
+    ReleaseBuffer(pbData);
+
+    return hr;
+}
+
+extern "C" HRESULT ElevationApplyUninitialize(
+    __in HANDLE hPipe
+    )
+{
+    HRESULT hr = S_OK;
+    BYTE* pbData = NULL;
+    SIZE_T cbData = 0;
+    DWORD dwResult = 0;
+
+    // send message
+    hr = PipeSendMessage(hPipe, BURN_ELEVATION_MESSAGE_TYPE_APPLY_UNINITIALIZE, pbData, cbData, NULL, NULL, &dwResult);
+    ExitOnFailure(hr, "Failed to send message to per-machine process.");
+
+    hr = (HRESULT)dwResult;
+
+LExit:
+    ReleaseBuffer(pbData);
+
+    return hr;
+}
+
+/*******************************************************************
+ ElevationSessionBegin - 
+
+*******************************************************************/
+extern "C" HRESULT ElevationSessionBegin(
+    __in HANDLE hPipe,
+    __in_z LPCWSTR wzEngineWorkingPath,
+    __in_z LPCWSTR wzResumeCommandLine,
+    __in BOOL fDisableResume,
+    __in BURN_VARIABLES* pVariables,
+    __in DWORD dwRegistrationOperations,
+    __in BURN_DEPENDENCY_REGISTRATION_ACTION dependencyRegistrationAction,
+    __in DWORD64 qwEstimatedSize
+    )
+{
+    HRESULT hr = S_OK;
+    BYTE* pbData = NULL;
+    SIZE_T cbData = 0;
+    DWORD dwResult = 0;
+
+    // serialize message data
+    hr = BuffWriteString(&pbData, &cbData, wzEngineWorkingPath);
+    ExitOnFailure(hr, "Failed to write engine working path to message buffer.");
+
+    hr = BuffWriteString(&pbData, &cbData, wzResumeCommandLine);
+    ExitOnFailure(hr, "Failed to write resume command line to message buffer.");
+
+    hr = BuffWriteNumber(&pbData, &cbData, fDisableResume);
+    ExitOnFailure(hr, "Failed to write resume flag.");
+
+    hr = BuffWriteNumber(&pbData, &cbData, dwRegistrationOperations);
+    ExitOnFailure(hr, "Failed to write registration operations to message buffer.");
+
+    hr = BuffWriteNumber(&pbData, &cbData, (DWORD)dependencyRegistrationAction);
+    ExitOnFailure(hr, "Failed to write dependency registration action to message buffer.");
+
+    hr = BuffWriteNumber64(&pbData, &cbData, qwEstimatedSize);
+    ExitOnFailure(hr, "Failed to write estimated size to message buffer.");
+
+    hr = VariableSerialize(pVariables, FALSE, &pbData, &cbData);
+    ExitOnFailure(hr, "Failed to write variables.");
+
+    // send message
+    hr = PipeSendMessage(hPipe, BURN_ELEVATION_MESSAGE_TYPE_SESSION_BEGIN, pbData, cbData, NULL, NULL, &dwResult);
+    ExitOnFailure(hr, "Failed to send message to per-machine process.");
+
+    hr = (HRESULT)dwResult;
+
+LExit:
+    ReleaseBuffer(pbData);
+
+    return hr;
+}
+
+/*******************************************************************
+ ElevationSessionResume - 
+
+*******************************************************************/
+extern "C" HRESULT ElevationSessionResume(
+    __in HANDLE hPipe,
+    __in_z LPCWSTR wzResumeCommandLine,
+    __in BOOL fDisableResume,
+    __in BURN_VARIABLES* pVariables
+    )
+{
+    HRESULT hr = S_OK;
+    BYTE* pbData = NULL;
+    SIZE_T cbData = 0;
+    DWORD dwResult = 0;
+
+    // serialize message data
+    hr = BuffWriteString(&pbData, &cbData, wzResumeCommandLine);
+    ExitOnFailure(hr, "Failed to write resume command line to message buffer.");
+
+    hr = BuffWriteNumber(&pbData, &cbData, fDisableResume);
+    ExitOnFailure(hr, "Failed to write resume flag.");
+
+    hr = VariableSerialize(pVariables, FALSE, &pbData, &cbData);
+    ExitOnFailure(hr, "Failed to write variables.");
+
+    // send message
+    hr = PipeSendMessage(hPipe, BURN_ELEVATION_MESSAGE_TYPE_SESSION_RESUME, pbData, cbData, NULL, NULL, &dwResult);
+    ExitOnFailure(hr, "Failed to send message to per-machine process.");
+
+    hr = (HRESULT)dwResult;
+
+LExit:
+    ReleaseBuffer(pbData);
+
+    return hr;
+}
+
+/*******************************************************************
+ ElevationSessionEnd - 
+
+*******************************************************************/
+extern "C" HRESULT ElevationSessionEnd(
+    __in HANDLE hPipe,
+    __in BURN_RESUME_MODE resumeMode,
+    __in BOOTSTRAPPER_APPLY_RESTART restart,
+    __in BURN_DEPENDENCY_REGISTRATION_ACTION dependencyRegistrationAction
+    )
+{
+    HRESULT hr = S_OK;
+    BYTE* pbData = NULL;
+    SIZE_T cbData = 0;
+    DWORD dwResult = 0;
+
+    // serialize message data
+    hr = BuffWriteNumber(&pbData, &cbData, (DWORD)resumeMode);
+    ExitOnFailure(hr, "Failed to write resume mode to message buffer.");
+
+    hr = BuffWriteNumber(&pbData, &cbData, (DWORD)restart);
+    ExitOnFailure(hr, "Failed to write restart enum to message buffer.");
+
+    hr = BuffWriteNumber(&pbData, &cbData, (DWORD)dependencyRegistrationAction);
+    ExitOnFailure(hr, "Failed to write dependency registration action to message buffer.");
+
+    // send message
+    hr = PipeSendMessage(hPipe, BURN_ELEVATION_MESSAGE_TYPE_SESSION_END, pbData, cbData, NULL, NULL, &dwResult);
+    ExitOnFailure(hr, "Failed to send message to per-machine process.");
+
+    hr = (HRESULT)dwResult;
+
+LExit:
+    ReleaseBuffer(pbData);
+
+    return hr;
+}
+
+/*******************************************************************
+ ElevationSaveState - 
+
+*******************************************************************/
+HRESULT ElevationSaveState(
+    __in HANDLE hPipe,
+    __in_bcount(cbBuffer) BYTE* pbBuffer,
+    __in SIZE_T cbBuffer
+    )
+{
+    HRESULT hr = S_OK;
+    DWORD dwResult = 0;
+
+    // send message
+    hr = PipeSendMessage(hPipe, BURN_ELEVATION_MESSAGE_TYPE_SAVE_STATE, pbBuffer, (DWORD)cbBuffer, NULL, NULL, &dwResult);
+    ExitOnFailure(hr, "Failed to send message to per-machine process.");
+
+    hr = (HRESULT)dwResult;
+
+LExit:
+    return hr;
+}
+
+/*******************************************************************
+ ElevationLayoutBundle - 
+
+*******************************************************************/
+extern "C" HRESULT ElevationLayoutBundle(
+    __in HANDLE hPipe,
+    __in_z LPCWSTR wzLayoutDirectory,
+    __in_z LPCWSTR wzUnverifiedPath
+    )
+{
+    HRESULT hr = S_OK;
+    BYTE* pbData = NULL;
+    SIZE_T cbData = 0;
+    DWORD dwResult = 0;
+
+    // serialize message data
+    hr = BuffWriteString(&pbData, &cbData, wzLayoutDirectory);
+    ExitOnFailure(hr, "Failed to write layout directory to message buffer.");
+
+    hr = BuffWriteString(&pbData, &cbData, wzUnverifiedPath);
+    ExitOnFailure(hr, "Failed to write payload unverified path to message buffer.");
+
+    // send message
+    hr = PipeSendMessage(hPipe, BURN_ELEVATION_MESSAGE_TYPE_LAYOUT_BUNDLE, pbData, cbData, NULL, NULL, &dwResult);
+    ExitOnFailure(hr, "Failed to send BURN_ELEVATION_MESSAGE_TYPE_LAYOUT_BUNDLE message to per-machine process.");
+
+    hr = (HRESULT)dwResult;
+
+LExit:
+    ReleaseBuffer(pbData);
+
+    return hr;
+}
+
+/*******************************************************************
+ ElevationCacheOrLayoutPayload - 
+
+*******************************************************************/
+extern "C" HRESULT ElevationCacheOrLayoutContainerOrPayload(
+    __in HANDLE hPipe,
+    __in_opt BURN_CONTAINER* pContainer,
+    __in_opt BURN_PACKAGE* pPackage,
+    __in_opt BURN_PAYLOAD* pPayload,
+    __in_z_opt LPCWSTR wzLayoutDirectory,
+    __in_z LPCWSTR wzUnverifiedPath,
+    __in BOOL fMove
+    )
+{
+    HRESULT hr = S_OK;
+    BYTE* pbData = NULL;
+    SIZE_T cbData = 0;
+    DWORD dwResult = 0;
+
+    // serialize message data
+    hr = BuffWriteString(&pbData, &cbData, pContainer ? pContainer->sczId : NULL);
+    ExitOnFailure(hr, "Failed to write container id to message buffer.");
+
+    hr = BuffWriteString(&pbData, &cbData, pPackage ? pPackage->sczId : NULL);
+    ExitOnFailure(hr, "Failed to write package id to message buffer.");
+
+    hr = BuffWriteString(&pbData, &cbData, pPayload ? pPayload->sczKey : NULL);
+    ExitOnFailure(hr, "Failed to write payload id to message buffer.");
+
+    hr = BuffWriteString(&pbData, &cbData, wzLayoutDirectory);
+    ExitOnFailure(hr, "Failed to write layout directory to message buffer.");
+
+    hr = BuffWriteString(&pbData, &cbData, wzUnverifiedPath);
+    ExitOnFailure(hr, "Failed to write unverified path to message buffer.");
+
+    hr = BuffWriteNumber(&pbData, &cbData, (DWORD)fMove);
+    ExitOnFailure(hr, "Failed to write move flag to message buffer.");
+
+    // send message
+    hr = PipeSendMessage(hPipe, BURN_ELEVATION_MESSAGE_TYPE_CACHE_OR_LAYOUT_CONTAINER_OR_PAYLOAD, pbData, cbData, NULL, NULL, &dwResult);
+    ExitOnFailure(hr, "Failed to send BURN_ELEVATION_MESSAGE_TYPE_CACHE_OR_LAYOUT_CONTAINER_OR_PAYLOAD message to per-machine process.");
+
+    hr = (HRESULT)dwResult;
+
+LExit:
+    ReleaseBuffer(pbData);
+
+    return hr;
+}
+
+/*******************************************************************
+ ElevationCacheCleanup - 
+
+*******************************************************************/
+extern "C" HRESULT ElevationCacheCleanup(
+    __in HANDLE hPipe
+    )
+{
+    HRESULT hr = S_OK;
+    DWORD dwResult = 0;
+
+    // send message
+    hr = PipeSendMessage(hPipe, BURN_ELEVATION_MESSAGE_TYPE_CACHE_CLEANUP, NULL, 0, NULL, NULL, &dwResult);
+    ExitOnFailure(hr, "Failed to send BURN_ELEVATION_MESSAGE_TYPE_CACHE_CLEANUP message to per-machine process.");
+
+    hr = (HRESULT)dwResult;
+
+LExit:
+    return hr;
+}
+
+extern "C" HRESULT ElevationProcessDependentRegistration(
+    __in HANDLE hPipe,
+    __in const BURN_DEPENDENT_REGISTRATION_ACTION* pAction
+    )
+{
+    HRESULT hr = S_OK;
+    BYTE* pbData = NULL;
+    SIZE_T cbData = 0;
+    DWORD dwResult = 0;
+
+    // serialize message data
+    hr = BuffWriteNumber(&pbData, &cbData, pAction->type);
+    ExitOnFailure(hr, "Failed to write action type to message buffer.");
+
+    hr = BuffWriteString(&pbData, &cbData, pAction->sczBundleId);
+    ExitOnFailure(hr, "Failed to write bundle id to message buffer.");
+
+    hr = BuffWriteString(&pbData, &cbData, pAction->sczDependentProviderKey);
+    ExitOnFailure(hr, "Failed to write dependent provider key to message buffer.");
+
+    // send message
+    hr = PipeSendMessage(hPipe, BURN_ELEVATION_MESSAGE_TYPE_PROCESS_DEPENDENT_REGISTRATION, pbData, cbData, NULL, NULL, &dwResult);
+    ExitOnFailure(hr, "Failed to send BURN_ELEVATION_MESSAGE_TYPE_PROCESS_DEPENDENT_REGISTRATION message to per-machine process.");
+
+    hr = (HRESULT)dwResult;
+
+LExit:
+    ReleaseBuffer(pbData);
+
+    return hr;
+}
+
+/*******************************************************************
+ ElevationExecuteExePackage - 
+
+*******************************************************************/
+extern "C" HRESULT ElevationExecuteExePackage(
+    __in HANDLE hPipe,
+    __in BURN_EXECUTE_ACTION* pExecuteAction,
+    __in BURN_VARIABLES* pVariables,
+    __in BOOL fRollback,
+    __in PFN_GENERICMESSAGEHANDLER pfnGenericMessageHandler,
+    __in LPVOID pvContext,
+    __out BOOTSTRAPPER_APPLY_RESTART* pRestart
+    )
+{
+    HRESULT hr = S_OK;
+    BYTE* pbData = NULL;
+    SIZE_T cbData = 0;
+    BURN_ELEVATION_GENERIC_MESSAGE_CONTEXT context = { };
+    DWORD dwResult = 0;
+
+    // serialize message data
+    hr = BuffWriteString(&pbData, &cbData, pExecuteAction->exePackage.pPackage->sczId);
+    ExitOnFailure(hr, "Failed to write package id to message buffer.");
+
+    hr = BuffWriteNumber(&pbData, &cbData, (DWORD)pExecuteAction->exePackage.action);
+    ExitOnFailure(hr, "Failed to write action to message buffer.");
+
+    hr = BuffWriteNumber(&pbData, &cbData, fRollback);
+    ExitOnFailure(hr, "Failed to write rollback.");
+
+    hr = BuffWriteString(&pbData, &cbData, pExecuteAction->exePackage.sczIgnoreDependencies);
+    ExitOnFailure(hr, "Failed to write the list of dependencies to ignore to the message buffer.");
+
+    hr = BuffWriteString(&pbData, &cbData, pExecuteAction->exePackage.sczAncestors);
+    ExitOnFailure(hr, "Failed to write the list of ancestors to the message buffer.");
+
+    hr = VariableSerialize(pVariables, FALSE, &pbData, &cbData);
+    ExitOnFailure(hr, "Failed to write variables.");
+
+    // send message
+    context.pfnGenericMessageHandler = pfnGenericMessageHandler;
+    context.pvContext = pvContext;
+
+    hr = PipeSendMessage(hPipe, BURN_ELEVATION_MESSAGE_TYPE_EXECUTE_EXE_PACKAGE, pbData, cbData, ProcessGenericExecuteMessages, &context, &dwResult);
+    ExitOnFailure(hr, "Failed to send BURN_ELEVATION_MESSAGE_TYPE_EXECUTE_EXE_PACKAGE message to per-machine process.");
+
+    hr = ProcessResult(dwResult, pRestart);
+
+LExit:
+    ReleaseBuffer(pbData);
+
+    return hr;
+}
+
+extern "C" HRESULT ElevationMsiBeginTransaction(
+    __in HANDLE hPipe,
+    __in_opt HWND hwndParent,
+    __in LPVOID pvContext
+)
+{
+    UNREFERENCED_PARAMETER(hwndParent);
+    HRESULT hr = S_OK;
+    BURN_ELEVATION_MSI_MESSAGE_CONTEXT context = {};
+    DWORD dwResult = ERROR_SUCCESS;
+
+    context.pvContext = pvContext;
+
+    hr = PipeSendMessage(hPipe, BURN_ELEVATION_TRANSACTION_BEGIN, NULL, 0, NULL, &context, &dwResult);
+    ExitOnFailure(hr, "Failed to send BURN_ELEVATION_MESSAGE_TYPE_EXECUTE_MSI_PACKAGE message to per-machine process.");
+    ExitOnWin32Error(dwResult, hr, "Failed beginning an elevated MSI transaction");
+
+LExit:
+    return hr;
+}
+
+extern "C" HRESULT ElevationMsiCommitTransaction(
+    __in HANDLE hPipe,
+    __in_opt HWND hwndParent,
+    __in LPVOID pvContext
+)
+{
+    UNREFERENCED_PARAMETER(hwndParent);
+    HRESULT hr = S_OK;
+    BURN_ELEVATION_MSI_MESSAGE_CONTEXT context = {};
+    DWORD dwResult = ERROR_SUCCESS;
+
+    context.pvContext = pvContext;
+
+    hr = PipeSendMessage(hPipe, BURN_ELEVATION_TRANSACTION_COMMIT, NULL, 0, NULL, &context, &dwResult);
+    ExitOnFailure(hr, "Failed to send BURN_ELEVATION_MESSAGE_TYPE_EXECUTE_MSI_PACKAGE message to per-machine process.");
+    ExitOnWin32Error(dwResult, hr, "Failed committing an elevated MSI transaction");
+
+LExit:
+    return hr;
+}
+
+extern "C" HRESULT ElevationMsiRollbackTransaction(
+    __in HANDLE hPipe,
+    __in_opt HWND hwndParent,
+    __in LPVOID pvContext
+)
+{
+    UNREFERENCED_PARAMETER(hwndParent);
+    HRESULT hr = S_OK;
+    BURN_ELEVATION_MSI_MESSAGE_CONTEXT context = {};
+    DWORD dwResult = ERROR_SUCCESS;
+
+    context.pvContext = pvContext;
+
+    hr = PipeSendMessage(hPipe, BURN_ELEVATION_TRANSACTION_ROLLBACK, NULL, 0, NULL, &context, &dwResult);
+    ExitOnFailure(hr, "Failed to send BURN_ELEVATION_MESSAGE_TYPE_EXECUTE_MSI_PACKAGE message to per-machine process.");
+    ExitOnWin32Error(dwResult, hr, "Failed rolling back an elevated MSI transaction");
+
+LExit:
+    return hr;
+}
+
+
+
+/*******************************************************************
+ ElevationExecuteMsiPackage - 
+
+*******************************************************************/
+extern "C" HRESULT ElevationExecuteMsiPackage(
+    __in HANDLE hPipe,
+    __in_opt HWND hwndParent,
+    __in BURN_EXECUTE_ACTION* pExecuteAction,
+    __in BURN_VARIABLES* pVariables,
+    __in BOOL fRollback,
+    __in PFN_MSIEXECUTEMESSAGEHANDLER pfnMessageHandler,
+    __in LPVOID pvContext,
+    __out BOOTSTRAPPER_APPLY_RESTART* pRestart
+    )
+{
+    HRESULT hr = S_OK;
+    BYTE* pbData = NULL;
+    SIZE_T cbData = 0;
+    BURN_ELEVATION_MSI_MESSAGE_CONTEXT context = { };
+    DWORD dwResult = 0;
+
+    // serialize message data
+    // TODO: for patching we might not have a package
+    hr = BuffWriteString(&pbData, &cbData, pExecuteAction->msiPackage.pPackage->sczId);
+    ExitOnFailure(hr, "Failed to write package id to message buffer.");
+
+    hr = BuffWriteNumber(&pbData, &cbData, (DWORD)hwndParent);
+    ExitOnFailure(hr, "Failed to write parent hwnd to message buffer.");
+
+    hr = BuffWriteString(&pbData, &cbData, pExecuteAction->msiPackage.sczLogPath);
+    ExitOnFailure(hr, "Failed to write package log to message buffer.");
+
+    hr = BuffWriteNumber(&pbData, &cbData, (DWORD)pExecuteAction->msiPackage.uiLevel);
+    ExitOnFailure(hr, "Failed to write UI level to message buffer.");
+
+    hr = BuffWriteNumber(&pbData, &cbData, (DWORD)pExecuteAction->msiPackage.action);
+    ExitOnFailure(hr, "Failed to write action to message buffer.");
+
+    // Feature actions.
+    for (DWORD i = 0; i < pExecuteAction->msiPackage.pPackage->Msi.cFeatures; ++i)
+    {
+        hr = BuffWriteNumber(&pbData, &cbData, (DWORD)pExecuteAction->msiPackage.rgFeatures[i]);
+        ExitOnFailure(hr, "Failed to write feature action to message buffer.");
+    }
+
+    // Slipstream patches actions.
+    for (DWORD i = 0; i < pExecuteAction->msiPackage.pPackage->Msi.cSlipstreamMspPackages; ++i)
+    {
+        hr = BuffWriteNumber(&pbData, &cbData, (DWORD)pExecuteAction->msiPackage.rgSlipstreamPatches[i]);
+        ExitOnFailure(hr, "Failed to write slipstream patch action to message buffer.");
+    }
+
+    hr = VariableSerialize(pVariables, FALSE, &pbData, &cbData);
+    ExitOnFailure(hr, "Failed to write variables.");
+
+    hr = BuffWriteNumber(&pbData, &cbData, (DWORD)fRollback);
+    ExitOnFailure(hr, "Failed to write rollback flag to message buffer.");
+
+
+    // send message
+    context.pfnMessageHandler = pfnMessageHandler;
+    context.pvContext = pvContext;
+
+    hr = PipeSendMessage(hPipe, BURN_ELEVATION_MESSAGE_TYPE_EXECUTE_MSI_PACKAGE, pbData, cbData, ProcessMsiPackageMessages, &context, &dwResult);
+    ExitOnFailure(hr, "Failed to send BURN_ELEVATION_MESSAGE_TYPE_EXECUTE_MSI_PACKAGE message to per-machine process.");
+
+    hr = ProcessResult(dwResult, pRestart);
+
+LExit:
+    ReleaseBuffer(pbData);
+
+    return hr;
+}
+
+/*******************************************************************
+ ElevationExecuteMspPackage - 
+
+*******************************************************************/
+extern "C" HRESULT ElevationExecuteMspPackage(
+    __in HANDLE hPipe,
+    __in_opt HWND hwndParent,
+    __in BURN_EXECUTE_ACTION* pExecuteAction,
+    __in BURN_VARIABLES* pVariables,
+    __in BOOL fRollback,
+    __in PFN_MSIEXECUTEMESSAGEHANDLER pfnMessageHandler,
+    __in LPVOID pvContext,
+    __out BOOTSTRAPPER_APPLY_RESTART* pRestart
+    )
+{
+    HRESULT hr = S_OK;
+    BYTE* pbData = NULL;
+    SIZE_T cbData = 0;
+    BURN_ELEVATION_MSI_MESSAGE_CONTEXT context = { };
+    DWORD dwResult = 0;
+
+    // serialize message data
+    hr = BuffWriteString(&pbData, &cbData, pExecuteAction->mspTarget.pPackage->sczId);
+    ExitOnFailure(hr, "Failed to write package id to message buffer.");
+
+    hr = BuffWriteNumber(&pbData, &cbData, (DWORD)hwndParent);
+    ExitOnFailure(hr, "Failed to write parent hwnd to message buffer.");
+
+    hr = BuffWriteString(&pbData, &cbData, pExecuteAction->mspTarget.sczTargetProductCode);
+    ExitOnFailure(hr, "Failed to write target product code to message buffer.");
+
+    hr = BuffWriteString(&pbData, &cbData, pExecuteAction->mspTarget.sczLogPath);
+    ExitOnFailure(hr, "Failed to write package log to message buffer.");
+
+    hr = BuffWriteNumber(&pbData, &cbData, (DWORD)pExecuteAction->mspTarget.uiLevel);
+    ExitOnFailure(hr, "Failed to write UI level to message buffer.");
+
+    hr = BuffWriteNumber(&pbData, &cbData, (DWORD)pExecuteAction->mspTarget.action);
+    ExitOnFailure(hr, "Failed to write action to message buffer.");
+
+    hr = BuffWriteNumber(&pbData, &cbData, pExecuteAction->mspTarget.cOrderedPatches);
+    ExitOnFailure(hr, "Failed to write count of ordered patches to message buffer.");
+
+    for (DWORD i = 0; i < pExecuteAction->mspTarget.cOrderedPatches; ++i)
+    {
+        hr = BuffWriteNumber(&pbData, &cbData, pExecuteAction->mspTarget.rgOrderedPatches[i].dwOrder);
+        ExitOnFailure(hr, "Failed to write ordered patch order to message buffer.");
+
+        hr = BuffWriteString(&pbData, &cbData, pExecuteAction->mspTarget.rgOrderedPatches[i].pPackage->sczId);
+        ExitOnFailure(hr, "Failed to write ordered patch id to message buffer.");
+    }
+
+    hr = VariableSerialize(pVariables, FALSE, &pbData, &cbData);
+    ExitOnFailure(hr, "Failed to write variables.");
+
+    hr = BuffWriteNumber(&pbData, &cbData, (DWORD)fRollback);
+    ExitOnFailure(hr, "Failed to write rollback flag to message buffer.");
+
+    // send message
+    context.pfnMessageHandler = pfnMessageHandler;
+    context.pvContext = pvContext;
+
+    hr = PipeSendMessage(hPipe, BURN_ELEVATION_MESSAGE_TYPE_EXECUTE_MSP_PACKAGE, pbData, cbData, ProcessMsiPackageMessages, &context, &dwResult);
+    ExitOnFailure(hr, "Failed to send BURN_ELEVATION_MESSAGE_TYPE_EXECUTE_MSP_PACKAGE message to per-machine process.");
+
+    hr = ProcessResult(dwResult, pRestart);
+
+LExit:
+    ReleaseBuffer(pbData);
+
+    return hr;
+}
+
+/*******************************************************************
+ ElevationExecuteMsuPackage - 
+
+*******************************************************************/
+extern "C" HRESULT ElevationExecuteMsuPackage(
+    __in HANDLE hPipe,
+    __in BURN_EXECUTE_ACTION* pExecuteAction,
+    __in BOOL fRollback,
+    __in BOOL fStopWusaService,
+    __in PFN_GENERICMESSAGEHANDLER pfnGenericMessageHandler,
+    __in LPVOID pvContext,
+    __out BOOTSTRAPPER_APPLY_RESTART* pRestart
+    )
+{
+    HRESULT hr = S_OK;
+    BYTE* pbData = NULL;
+    SIZE_T cbData = 0;
+    BURN_ELEVATION_GENERIC_MESSAGE_CONTEXT context = { };
+    DWORD dwResult = 0;
+
+    // serialize message data
+    hr = BuffWriteString(&pbData, &cbData, pExecuteAction->msuPackage.pPackage->sczId);
+    ExitOnFailure(hr, "Failed to write package id to message buffer.");
+
+    hr = BuffWriteString(&pbData, &cbData, pExecuteAction->msuPackage.sczLogPath);
+    ExitOnFailure(hr, "Failed to write package log to message buffer.");
+
+    hr = BuffWriteNumber(&pbData, &cbData, (DWORD)pExecuteAction->msuPackage.action);
+    ExitOnFailure(hr, "Failed to write action to message buffer.");
+
+    hr = BuffWriteNumber(&pbData, &cbData, fRollback);
+    ExitOnFailure(hr, "Failed to write rollback.");
+
+    hr = BuffWriteNumber(&pbData, &cbData, fStopWusaService);
+    ExitOnFailure(hr, "Failed to write StopWusaService.");
+
+    // send message
+    context.pfnGenericMessageHandler = pfnGenericMessageHandler;
+    context.pvContext = pvContext;
+
+    hr = PipeSendMessage(hPipe, BURN_ELEVATION_MESSAGE_TYPE_EXECUTE_MSU_PACKAGE, pbData, cbData, ProcessGenericExecuteMessages, &context, &dwResult);
+    ExitOnFailure(hr, "Failed to send BURN_ELEVATION_MESSAGE_TYPE_EXECUTE_MSU_PACKAGE message to per-machine process.");
+
+    hr = ProcessResult(dwResult, pRestart);
+
+LExit:
+    ReleaseBuffer(pbData);
+
+    return hr;
+}
+
+extern "C" HRESULT ElevationExecutePackageProviderAction(
+    __in HANDLE hPipe,
+    __in BURN_EXECUTE_ACTION* pExecuteAction
+    )
+{
+    HRESULT hr = S_OK;
+    BYTE* pbData = NULL;
+    SIZE_T cbData = 0;
+    DWORD dwResult = 0;
+    BOOTSTRAPPER_APPLY_RESTART restart = BOOTSTRAPPER_APPLY_RESTART_NONE;
+
+    // Serialize the message data.
+    hr = BuffWriteString(&pbData, &cbData, pExecuteAction->packageProvider.pPackage->sczId);
+    ExitOnFailure(hr, "Failed to write package id to message buffer.");
+
+    hr = BuffWriteNumber(&pbData, &cbData, pExecuteAction->packageProvider.action);
+    ExitOnFailure(hr, "Failed to write action to message buffer.");
+
+    // Send the message.
+    hr = PipeSendMessage(hPipe, BURN_ELEVATION_MESSAGE_TYPE_EXECUTE_PACKAGE_PROVIDER, pbData, cbData, NULL, NULL, &dwResult);
+    ExitOnFailure(hr, "Failed to send BURN_ELEVATION_MESSAGE_TYPE_EXECUTE_PACKAGE_PROVIDER message to per-machine process.");
+
+    // Ignore the restart since this action only results in registry writes.
+    hr = ProcessResult(dwResult, &restart);
+
+LExit:
+    ReleaseBuffer(pbData);
+
+    return hr;
+}
+
+extern "C" HRESULT ElevationExecutePackageDependencyAction(
+    __in HANDLE hPipe,
+    __in BURN_EXECUTE_ACTION* pExecuteAction
+    )
+{
+    HRESULT hr = S_OK;
+    BYTE* pbData = NULL;
+    SIZE_T cbData = 0;
+    DWORD dwResult = 0;
+    BOOTSTRAPPER_APPLY_RESTART restart = BOOTSTRAPPER_APPLY_RESTART_NONE;
+
+    // Serialize the message data.
+    hr = BuffWriteString(&pbData, &cbData, pExecuteAction->packageDependency.pPackage->sczId);
+    ExitOnFailure(hr, "Failed to write package id to message buffer.");
+
+    hr = BuffWriteString(&pbData, &cbData, pExecuteAction->packageDependency.sczBundleProviderKey);
+    ExitOnFailure(hr, "Failed to write bundle dependency key to message buffer.");
+
+    hr = BuffWriteNumber(&pbData, &cbData, pExecuteAction->packageDependency.action);
+    ExitOnFailure(hr, "Failed to write action to message buffer.");
+
+    // Send the message.
+    hr = PipeSendMessage(hPipe, BURN_ELEVATION_MESSAGE_TYPE_EXECUTE_PACKAGE_DEPENDENCY, pbData, cbData, NULL, NULL, &dwResult);
+    ExitOnFailure(hr, "Failed to send BURN_ELEVATION_MESSAGE_TYPE_EXECUTE_PACKAGE_DEPENDENCY message to per-machine process.");
+
+    // Ignore the restart since this action only results in registry writes.
+    hr = ProcessResult(dwResult, &restart);
+
+LExit:
+    ReleaseBuffer(pbData);
+
+    return hr;
+}
+
+/*******************************************************************
+ ElevationLoadCompatiblePackageAction - Load compatible package
+  information from the referenced package.
+
+*******************************************************************/
+extern "C" HRESULT ElevationLoadCompatiblePackageAction(
+    __in HANDLE hPipe,
+    __in BURN_EXECUTE_ACTION* pExecuteAction
+    )
+{
+    HRESULT hr = S_OK;
+    BYTE* pbData = NULL;
+    SIZE_T cbData = 0;
+    DWORD dwResult = 0;
+    BOOTSTRAPPER_APPLY_RESTART restart = BOOTSTRAPPER_APPLY_RESTART_NONE;
+
+    // Serialize message data.
+    hr = BuffWriteString(&pbData, &cbData, pExecuteAction->compatiblePackage.pReferencePackage->sczId);
+    ExitOnFailure(hr, "Failed to write package id to message buffer.");
+
+    hr = BuffWriteString(&pbData, &cbData, pExecuteAction->compatiblePackage.sczInstalledProductCode);
+    ExitOnFailure(hr, "Failed to write installed ProductCode to message buffer.");
+
+    hr = BuffWriteNumber64(&pbData, &cbData, pExecuteAction->compatiblePackage.qwInstalledVersion);
+    ExitOnFailure(hr, "Failed to write installed version to message buffer.");
+
+    // Send the message.
+    hr = PipeSendMessage(hPipe, BURN_ELEVATION_MESSAGE_TYPE_LOAD_COMPATIBLE_PACKAGE, pbData, cbData, NULL, NULL, &dwResult);
+    ExitOnFailure(hr, "Failed to send BURN_ELEVATION_MESSAGE_TYPE_LOAD_COMPATIBLE_PACKAGE message to per-machine process.");
+
+    // Ignore the restart since this action only loads data into memory.
+    hr = ProcessResult(dwResult, &restart);
+
+LExit:
+    ReleaseBuffer(pbData);
+
+    return hr;
+}
+
+/*******************************************************************
+ ElevationCleanPackage - 
+
+*******************************************************************/
+extern "C" HRESULT ElevationCleanPackage(
+    __in HANDLE hPipe,
+    __in BURN_PACKAGE* pPackage
+    )
+{
+    HRESULT hr = S_OK;
+    BYTE* pbData = NULL;
+    SIZE_T cbData = 0;
+    DWORD dwResult = 0;
+
+    // serialize message data
+    hr = BuffWriteString(&pbData, &cbData, pPackage->sczId);
+    ExitOnFailure(hr, "Failed to write clean package id to message buffer.");
+
+    // send message
+    hr = PipeSendMessage(hPipe, BURN_ELEVATION_MESSAGE_TYPE_CLEAN_PACKAGE, pbData, cbData, NULL, NULL, &dwResult);
+    ExitOnFailure(hr, "Failed to send BURN_ELEVATION_MESSAGE_TYPE_CLEAN_PACKAGE message to per-machine process.");
+
+    hr = (HRESULT)dwResult;
+
+LExit:
+    ReleaseBuffer(pbData);
+
+    return hr;
+}
+
+extern "C" HRESULT ElevationLaunchApprovedExe(
+    __in HANDLE hPipe,
+    __in BURN_LAUNCH_APPROVED_EXE* pLaunchApprovedExe,
+    __out DWORD* pdwProcessId
+    )
+{
+    HRESULT hr = S_OK;
+    BYTE* pbData = NULL;
+    SIZE_T cbData = 0;
+    DWORD dwResult = 0;
+    BURN_ELEVATION_LAUNCH_APPROVED_EXE_MESSAGE_CONTEXT context = { };
+
+    // Serialize message data.
+    hr = BuffWriteString(&pbData, &cbData, pLaunchApprovedExe->sczId);
+    ExitOnFailure(hr, "Failed to write approved exe id to message buffer.");
+
+    hr = BuffWriteString(&pbData, &cbData, pLaunchApprovedExe->sczArguments);
+    ExitOnFailure(hr, "Failed to write approved exe arguments to message buffer.");
+
+    hr = BuffWriteNumber(&pbData, &cbData, pLaunchApprovedExe->dwWaitForInputIdleTimeout);
+    ExitOnFailure(hr, "Failed to write approved exe WaitForInputIdle timeout to message buffer.");
+
+    // Send the message.
+    hr = PipeSendMessage(hPipe, BURN_ELEVATION_MESSAGE_TYPE_LAUNCH_APPROVED_EXE, pbData, cbData, ProcessLaunchApprovedExeMessages, &context, &dwResult);
+    ExitOnFailure(hr, "Failed to send BURN_ELEVATION_MESSAGE_TYPE_LAUNCH_APPROVED_EXE message to per-machine process.");
+
+    hr = (HRESULT)dwResult;
+    *pdwProcessId = context.dwProcessId;
+
+LExit:
+    ReleaseBuffer(pbData);
+
+    return hr;
+}
+
+/*******************************************************************
+ ElevationChildPumpMessages - 
+
+*******************************************************************/
+extern "C" HRESULT ElevationChildPumpMessages(
+    __in DWORD dwLoggingTlsId,
+    __in HANDLE hPipe,
+    __in HANDLE hCachePipe,
+    __in BURN_APPROVED_EXES* pApprovedExes,
+    __in BURN_CONTAINERS* pContainers,
+    __in BURN_PACKAGES* pPackages,
+    __in BURN_PAYLOADS* pPayloads,
+    __in BURN_VARIABLES* pVariables,
+    __in BURN_REGISTRATION* pRegistration,
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __out HANDLE* phLock,
+    __out BOOL* pfDisabledAutomaticUpdates,
+    __out DWORD* pdwChildExitCode,
+    __out BOOL* pfRestart
+    )
+{
+    HRESULT hr = S_OK;
+    BURN_ELEVATION_CHILD_MESSAGE_CONTEXT cacheContext = { };
+    BURN_ELEVATION_CHILD_MESSAGE_CONTEXT context = { };
+    HANDLE hCacheThread = NULL;
+    BURN_PIPE_RESULT result = { };
+
+    cacheContext.dwLoggingTlsId = dwLoggingTlsId;
+    cacheContext.hPipe = hCachePipe;
+    cacheContext.pContainers = pContainers;
+    cacheContext.pPackages = pPackages;
+    cacheContext.pPayloads = pPayloads;
+    cacheContext.pVariables = pVariables;
+    cacheContext.pRegistration = pRegistration;
+    cacheContext.pUserExperience = pUserExperience;
+
+    context.dwLoggingTlsId = dwLoggingTlsId;
+    context.hPipe = hPipe;
+    context.phLock = phLock;
+    context.pfDisabledAutomaticUpdates = pfDisabledAutomaticUpdates;
+    context.pApprovedExes = pApprovedExes;
+    context.pContainers = pContainers;
+    context.pPackages = pPackages;
+    context.pPayloads = pPayloads;
+    context.pVariables = pVariables;
+    context.pRegistration = pRegistration;
+    context.pUserExperience = pUserExperience;
+
+    hCacheThread = ::CreateThread(NULL, 0, ElevatedChildCacheThreadProc, &cacheContext, 0, NULL);
+    ExitOnNullWithLastError(hCacheThread, hr, "Failed to create elevated cache thread.");
+
+    hr = PipePumpMessages(hPipe, ProcessElevatedChildMessage, &context, &result);
+    ExitOnFailure(hr, "Failed to pump messages in child process.");
+
+    // Wait for the cache thread and verify it gets the right result but don't fail if things
+    // don't work out.
+    WaitForElevatedChildCacheThread(hCacheThread, result.dwResult);
+
+    *pdwChildExitCode = result.dwResult;
+    *pfRestart = result.fRestart;
+
+LExit:
+    ReleaseHandle(hCacheThread);
+
+    return hr;
+}
+
+extern "C" HRESULT ElevationChildResumeAutomaticUpdates()
+{
+    HRESULT hr = S_OK;
+
+    LogId(REPORT_STANDARD, MSG_RESUME_AU_STARTING);
+
+    hr = WuaResumeAutomaticUpdates();
+    ExitOnFailure(hr, "Failed to resume automatic updates after pausing them, continuing...");
+
+    LogId(REPORT_STANDARD, MSG_RESUME_AU_SUCCEEDED);
+
+LExit:
+    return hr;
+}
+
+// internal function definitions
+
+static DWORD WINAPI ElevatedChildCacheThreadProc(
+    __in LPVOID lpThreadParameter
+    )
+{
+    HRESULT hr = S_OK;
+    BURN_ELEVATION_CHILD_MESSAGE_CONTEXT* pContext = reinterpret_cast<BURN_ELEVATION_CHILD_MESSAGE_CONTEXT*>(lpThreadParameter);
+    BOOL fComInitialized = FALSE;
+    BURN_PIPE_RESULT result = { };
+
+    if (!::TlsSetValue(pContext->dwLoggingTlsId, pContext->hPipe))
+    {
+        ExitWithLastError(hr, "Failed to set elevated cache pipe into thread local storage for logging.");
+    }
+
+    // initialize COM
+    hr = ::CoInitializeEx(NULL, COINIT_MULTITHREADED);
+    ExitOnFailure(hr, "Failed to initialize COM.");
+    fComInitialized = TRUE;
+
+    hr = PipePumpMessages(pContext->hPipe, ProcessElevatedChildCacheMessage, pContext, &result);
+    ExitOnFailure(hr, "Failed to pump messages in child process.");
+
+    hr = (HRESULT)result.dwResult;
+
+LExit:
+    if (fComInitialized)
+    {
+        ::CoUninitialize();
+    }
+
+    return (DWORD)hr;
+}
+
+static HRESULT WaitForElevatedChildCacheThread(
+    __in HANDLE hCacheThread,
+    __in DWORD dwExpectedExitCode
+    )
+{
+    UNREFERENCED_PARAMETER(dwExpectedExitCode);
+
+    HRESULT hr = S_OK;
+    DWORD dwExitCode = ERROR_SUCCESS;
+
+    if (WAIT_OBJECT_0 != ::WaitForSingleObject(hCacheThread, BURN_TIMEOUT))
+    {
+        ExitWithLastError(hr, "Failed to wait for cache thread to terminate.");
+    }
+
+    if (!::GetExitCodeThread(hCacheThread, &dwExitCode))
+    {
+        ExitWithLastError(hr, "Failed to get cache thread exit code.");
+    }
+
+    AssertSz(dwExitCode == dwExpectedExitCode, "Cache thread should have exited with the expected exit code.");
+
+LExit:
+    return hr;
+}
+
+static HRESULT ProcessGenericExecuteMessages(
+    __in BURN_PIPE_MESSAGE* pMsg,
+    __in_opt LPVOID pvContext,
+    __out DWORD* pdwResult
+    )
+{
+    HRESULT hr = S_OK;
+    SIZE_T iData = 0;
+    BURN_ELEVATION_GENERIC_MESSAGE_CONTEXT* pContext = static_cast<BURN_ELEVATION_GENERIC_MESSAGE_CONTEXT*>(pvContext);
+    LPWSTR sczMessage = NULL;
+    DWORD cFiles = 0;
+    LPWSTR* rgwzFiles = NULL;
+    GENERIC_EXECUTE_MESSAGE message = { };
+
+    hr = BuffReadNumber((BYTE*)pMsg->pvData, pMsg->cbData, &iData, &message.dwAllowedResults);
+    ExitOnFailure(hr, "Failed to allowed results.");
+    
+    // Process the message.
+    switch (pMsg->dwMessage)
+    {
+    case BURN_ELEVATION_MESSAGE_TYPE_EXECUTE_PROGRESS:
+        message.type = GENERIC_EXECUTE_MESSAGE_PROGRESS;
+
+        // read message parameters
+        hr = BuffReadNumber((BYTE*)pMsg->pvData, pMsg->cbData, &iData, &message.progress.dwPercentage);
+        ExitOnFailure(hr, "Failed to progress.");
+        break;
+
+    case BURN_ELEVATION_MESSAGE_TYPE_EXECUTE_ERROR:
+        message.type = GENERIC_EXECUTE_MESSAGE_ERROR;
+
+        // read message parameters
+        hr = BuffReadNumber((BYTE*)pMsg->pvData, pMsg->cbData, &iData, &message.error.dwErrorCode);
+        ExitOnFailure(hr, "Failed to read error code.");
+
+        hr = BuffReadString((BYTE*)pMsg->pvData, pMsg->cbData, &iData, &sczMessage);
+        ExitOnFailure(hr, "Failed to read message.");
+
+        message.error.wzMessage = sczMessage;
+        break;
+
+    case BURN_ELEVATION_MESSAGE_TYPE_EXECUTE_FILES_IN_USE:
+        message.type = GENERIC_EXECUTE_MESSAGE_FILES_IN_USE;
+
+        // read message parameters
+        hr = BuffReadNumber((BYTE*)pMsg->pvData, pMsg->cbData, &iData, &cFiles);
+        ExitOnFailure(hr, "Failed to read file count.");
+
+        rgwzFiles = (LPWSTR*)MemAlloc(sizeof(LPWSTR*) * cFiles, TRUE);
+        ExitOnNull(rgwzFiles, hr, E_OUTOFMEMORY, "Failed to allocate buffer for files in use.");
+
+        for (DWORD i = 0; i < cFiles; ++i)
+        {
+            hr = BuffReadString((BYTE*)pMsg->pvData, pMsg->cbData, &iData, &rgwzFiles[i]);
+            ExitOnFailure(hr, "Failed to read file name: %u", i);
+        }
+
+        message.filesInUse.cFiles = cFiles;
+        message.filesInUse.rgwzFiles = (LPCWSTR*)rgwzFiles;
+        break;
+
+    default:
+        hr = E_INVALIDARG;
+        ExitOnRootFailure(hr, "Invalid package message.");
+        break;
+    }
+
+    // send message
+    *pdwResult =  (DWORD)pContext->pfnGenericMessageHandler(&message, pContext->pvContext);;
+
+LExit:
+    ReleaseStr(sczMessage);
+
+    if (rgwzFiles)
+    {
+        for (DWORD i = 0; i < cFiles; ++i)
+        {
+            ReleaseStr(rgwzFiles[i]);
+        }
+        MemFree(rgwzFiles);
+    }
+    return hr;
+}
+
+static HRESULT ProcessMsiPackageMessages(
+    __in BURN_PIPE_MESSAGE* pMsg,
+    __in_opt LPVOID pvContext,
+    __out DWORD* pdwResult
+    )
+{
+    HRESULT hr = S_OK;
+    SIZE_T iData = 0;
+    WIU_MSI_EXECUTE_MESSAGE message = { };
+    DWORD cMsiData = 0;
+    LPWSTR* rgwzMsiData = NULL;
+    BURN_ELEVATION_MSI_MESSAGE_CONTEXT* pContext = static_cast<BURN_ELEVATION_MSI_MESSAGE_CONTEXT*>(pvContext);
+    LPWSTR sczMessage = NULL;
+
+    // Read MSI extended message data.
+    hr = BuffReadNumber((BYTE*)pMsg->pvData, pMsg->cbData, &iData, &cMsiData);
+    ExitOnFailure(hr, "Failed to read MSI data count.");
+
+    if (cMsiData)
+    {
+        rgwzMsiData = (LPWSTR*)MemAlloc(sizeof(LPWSTR*) * cMsiData, TRUE);
+        ExitOnNull(rgwzMsiData, hr, E_OUTOFMEMORY, "Failed to allocate buffer to read MSI data.");
+
+        for (DWORD i = 0; i < cMsiData; ++i)
+        {
+            hr = BuffReadString((BYTE*)pMsg->pvData, pMsg->cbData, &iData, &rgwzMsiData[i]);
+            ExitOnFailure(hr, "Failed to read MSI data: %u", i);
+        }
+
+        message.cData = cMsiData;
+        message.rgwzData = (LPCWSTR*)rgwzMsiData;
+    }
+
+    hr = BuffReadNumber((BYTE*)pMsg->pvData, pMsg->cbData, &iData, (DWORD*)&message.dwAllowedResults);
+    ExitOnFailure(hr, "Failed to read UI flags.");
+
+    // Process the rest of the message.
+    switch (pMsg->dwMessage)
+    {
+    case BURN_ELEVATION_MESSAGE_TYPE_EXECUTE_PROGRESS:
+        // read message parameters
+        message.type = WIU_MSI_EXECUTE_MESSAGE_PROGRESS;
+
+        hr = BuffReadNumber((BYTE*)pMsg->pvData, pMsg->cbData, &iData, &message.progress.dwPercentage);
+        ExitOnFailure(hr, "Failed to read progress.");
+        break;
+
+    case BURN_ELEVATION_MESSAGE_TYPE_EXECUTE_ERROR:
+        // read message parameters
+        message.type = WIU_MSI_EXECUTE_MESSAGE_ERROR;
+
+        hr = BuffReadNumber((BYTE*)pMsg->pvData, pMsg->cbData, &iData, &message.error.dwErrorCode);
+        ExitOnFailure(hr, "Failed to read error code.");
+
+        hr = BuffReadString((BYTE*)pMsg->pvData, pMsg->cbData, &iData, &sczMessage);
+        ExitOnFailure(hr, "Failed to read message.");
+        message.error.wzMessage = sczMessage;
+        break;
+
+    case BURN_ELEVATION_MESSAGE_TYPE_EXECUTE_MSI_MESSAGE:
+        // read message parameters
+        message.type = WIU_MSI_EXECUTE_MESSAGE_MSI_MESSAGE;
+
+        hr = BuffReadNumber((BYTE*)pMsg->pvData, pMsg->cbData, &iData, (DWORD*)&message.msiMessage.mt);
+        ExitOnFailure(hr, "Failed to read message type.");
+
+        hr = BuffReadString((BYTE*)pMsg->pvData, pMsg->cbData, &iData, &sczMessage);
+        ExitOnFailure(hr, "Failed to read message.");
+        message.msiMessage.wzMessage = sczMessage;
+        break;
+
+    case BURN_ELEVATION_MESSAGE_TYPE_EXECUTE_FILES_IN_USE:
+        message.type = WIU_MSI_EXECUTE_MESSAGE_MSI_FILES_IN_USE;
+        message.msiFilesInUse.cFiles = cMsiData;
+        message.msiFilesInUse.rgwzFiles = (LPCWSTR*)rgwzMsiData;
+        break;
+
+    default:
+        hr = E_INVALIDARG;
+        ExitOnRootFailure(hr, "Invalid package message.");
+        break;
+    }
+    
+    // send message
+    *pdwResult = (DWORD)pContext->pfnMessageHandler(&message, pContext->pvContext);
+
+LExit:
+    ReleaseStr(sczMessage);
+
+    if (rgwzMsiData)
+    {
+        for (DWORD i = 0; i < cMsiData; ++i)
+        {
+            ReleaseStr(rgwzMsiData[i]);
+        }
+
+        MemFree(rgwzMsiData);
+    }
+
+    return hr;
+}
+
+static HRESULT ProcessLaunchApprovedExeMessages(
+    __in BURN_PIPE_MESSAGE* pMsg,
+    __in_opt LPVOID pvContext,
+    __out DWORD* pdwResult
+    )
+{
+    HRESULT hr = S_OK;
+    SIZE_T iData = 0;
+    BURN_ELEVATION_LAUNCH_APPROVED_EXE_MESSAGE_CONTEXT* pContext = static_cast<BURN_ELEVATION_LAUNCH_APPROVED_EXE_MESSAGE_CONTEXT*>(pvContext);
+    DWORD dwProcessId = 0;
+
+    // Process the message.
+    switch (pMsg->dwMessage)
+    {
+    case BURN_ELEVATION_MESSAGE_TYPE_LAUNCH_APPROVED_EXE_PROCESSID:
+        // read message parameters
+        hr = BuffReadNumber((BYTE*)pMsg->pvData, pMsg->cbData, &iData, &dwProcessId);
+        ExitOnFailure(hr, "Failed to read approved exe process id.");
+        pContext->dwProcessId = dwProcessId;
+        break;
+
+    default:
+        hr = E_INVALIDARG;
+        ExitOnRootFailure(hr, "Invalid launch approved exe message.");
+        break;
+    }
+
+    *pdwResult = static_cast<DWORD>(hr);
+
+LExit:
+    return hr;
+}
+
+static HRESULT ProcessElevatedChildMessage(
+    __in BURN_PIPE_MESSAGE* pMsg,
+    __in_opt LPVOID pvContext,
+    __out DWORD* pdwResult
+)
+{
+    HRESULT hr = S_OK;
+    BURN_ELEVATION_CHILD_MESSAGE_CONTEXT* pContext = static_cast<BURN_ELEVATION_CHILD_MESSAGE_CONTEXT*>(pvContext);
+    HRESULT hrResult = S_OK;
+    DWORD dwPid = 0;
+
+    switch (pMsg->dwMessage)
+    {
+    case BURN_ELEVATION_TRANSACTION_BEGIN:
+        hrResult = OnMsiBeginTransaction(pContext);
+        break;
+
+    case BURN_ELEVATION_TRANSACTION_COMMIT:
+        hrResult = OnMsiCommitTransaction(pContext);
+        break;
+
+    case BURN_ELEVATION_TRANSACTION_ROLLBACK:
+        hrResult = OnMsiRollbackTransaction(pContext);
+        break;
+
+    case BURN_ELEVATION_MESSAGE_TYPE_APPLY_INITIALIZE:
+        hrResult = OnApplyInitialize(pContext->pVariables, pContext->pRegistration, pContext->phLock, pContext->pfDisabledAutomaticUpdates, (BYTE*)pMsg->pvData, pMsg->cbData);
+        break;
+
+    case BURN_ELEVATION_MESSAGE_TYPE_APPLY_UNINITIALIZE:
+        hrResult = OnApplyUninitialize(pContext->phLock);
+        break;
+
+    case BURN_ELEVATION_MESSAGE_TYPE_SESSION_BEGIN:
+        hrResult = OnSessionBegin(pContext->pRegistration, pContext->pVariables, pContext->pUserExperience, (BYTE*)pMsg->pvData, pMsg->cbData);
+        break;
+
+    case BURN_ELEVATION_MESSAGE_TYPE_SESSION_RESUME:
+        hrResult = OnSessionResume(pContext->pRegistration, pContext->pVariables, (BYTE*)pMsg->pvData, pMsg->cbData);
+        break;
+
+    case BURN_ELEVATION_MESSAGE_TYPE_SESSION_END:
+        hrResult = OnSessionEnd(pContext->pRegistration, (BYTE*)pMsg->pvData, pMsg->cbData);
+        break;
+
+    case BURN_ELEVATION_MESSAGE_TYPE_SAVE_STATE:
+        hrResult = OnSaveState(pContext->pRegistration, (BYTE*)pMsg->pvData, pMsg->cbData);
+        break;
+
+    case BURN_ELEVATION_MESSAGE_TYPE_PROCESS_DEPENDENT_REGISTRATION:
+        hrResult = OnProcessDependentRegistration(pContext->pRegistration, (BYTE*)pMsg->pvData, pMsg->cbData);
+        break;
+
+    case BURN_ELEVATION_MESSAGE_TYPE_EXECUTE_EXE_PACKAGE:
+        hrResult = OnExecuteExePackage(pContext->hPipe, pContext->pPackages, &pContext->pRegistration->relatedBundles, pContext->pVariables, (BYTE*)pMsg->pvData, pMsg->cbData);
+        break;
+
+    case BURN_ELEVATION_MESSAGE_TYPE_EXECUTE_MSI_PACKAGE:
+        hrResult = OnExecuteMsiPackage(pContext->hPipe, pContext->pPackages, pContext->pVariables, (BYTE*)pMsg->pvData, pMsg->cbData);
+        break;
+
+    case BURN_ELEVATION_MESSAGE_TYPE_EXECUTE_MSP_PACKAGE:
+        hrResult = OnExecuteMspPackage(pContext->hPipe, pContext->pPackages, pContext->pVariables, (BYTE*)pMsg->pvData, pMsg->cbData);
+        break;
+
+    case BURN_ELEVATION_MESSAGE_TYPE_EXECUTE_MSU_PACKAGE:
+        hrResult = OnExecuteMsuPackage(pContext->hPipe, pContext->pPackages, pContext->pVariables, (BYTE*)pMsg->pvData, pMsg->cbData);
+        break;
+
+    case BURN_ELEVATION_MESSAGE_TYPE_EXECUTE_PACKAGE_PROVIDER:
+        hrResult = OnExecutePackageProviderAction(pContext->pPackages, &pContext->pRegistration->relatedBundles, (BYTE*)pMsg->pvData, pMsg->cbData);
+        break;
+
+    case BURN_ELEVATION_MESSAGE_TYPE_EXECUTE_PACKAGE_DEPENDENCY:
+        hrResult = OnExecutePackageDependencyAction(pContext->pPackages, &pContext->pRegistration->relatedBundles, (BYTE*)pMsg->pvData, pMsg->cbData);
+        break;
+
+    case BURN_ELEVATION_MESSAGE_TYPE_LOAD_COMPATIBLE_PACKAGE:
+        hrResult = OnLoadCompatiblePackage(pContext->pPackages, (BYTE*)pMsg->pvData, pMsg->cbData);
+        break;
+
+    case BURN_ELEVATION_MESSAGE_TYPE_CLEAN_PACKAGE:
+        hrResult = OnCleanPackage(pContext->pPackages, (BYTE*)pMsg->pvData, pMsg->cbData);
+        break;
+
+    case BURN_ELEVATION_MESSAGE_TYPE_LAUNCH_APPROVED_EXE:
+        hrResult = OnLaunchApprovedExe(pContext->hPipe, pContext->pApprovedExes, pContext->pVariables, (BYTE*)pMsg->pvData, pMsg->cbData);
+        break;
+
+    default:
+        hr = E_INVALIDARG;
+        ExitOnRootFailure(hr, "Unexpected elevated message sent to child process, msg: %u", pMsg->dwMessage);
+    }
+
+    *pdwResult = dwPid ? dwPid : (DWORD)hrResult;
+
+LExit:
+    return hr;
+}
+
+static HRESULT ProcessElevatedChildCacheMessage(
+    __in BURN_PIPE_MESSAGE* pMsg,
+    __in_opt LPVOID pvContext,
+    __out DWORD* pdwResult
+    )
+{
+    HRESULT hr = S_OK;
+    BURN_ELEVATION_CHILD_MESSAGE_CONTEXT* pContext = static_cast<BURN_ELEVATION_CHILD_MESSAGE_CONTEXT*>(pvContext);
+    HRESULT hrResult = S_OK;
+
+    switch (pMsg->dwMessage)
+    {
+    case BURN_ELEVATION_MESSAGE_TYPE_LAYOUT_BUNDLE:
+        hrResult = OnLayoutBundle(pContext->pRegistration->sczExecutableName, (BYTE*)pMsg->pvData, pMsg->cbData);
+        break;
+
+    case BURN_ELEVATION_MESSAGE_TYPE_CACHE_OR_LAYOUT_CONTAINER_OR_PAYLOAD:
+        hrResult = OnCacheOrLayoutContainerOrPayload(pContext->pContainers, pContext->pPackages, pContext->pPayloads, (BYTE*)pMsg->pvData, pMsg->cbData);
+        break;
+
+    case BURN_ELEVATION_MESSAGE_TYPE_CACHE_CLEANUP:
+        OnCacheCleanup(pContext->pRegistration->sczId);
+        hrResult = S_OK;
+        break;
+
+    case BURN_ELEVATION_MESSAGE_TYPE_CLEAN_PACKAGE:
+        hrResult = OnCleanPackage(pContext->pPackages, (BYTE*)pMsg->pvData, pMsg->cbData);
+        break;
+
+    default:
+        hr = E_INVALIDARG;
+        ExitOnRootFailure(hr, "Unexpected elevated cache message sent to child process, msg: %u", pMsg->dwMessage);
+    }
+
+    *pdwResult = (DWORD)hrResult;
+
+LExit:
+    return hr;
+}
+
+static HRESULT ProcessResult(
+    __in DWORD dwResult,
+    __out BOOTSTRAPPER_APPLY_RESTART* pRestart
+    )
+{
+    HRESULT hr = static_cast<HRESULT>(dwResult);
+    if (HRESULT_FROM_WIN32(ERROR_SUCCESS_REBOOT_REQUIRED) == hr)
+    {
+        *pRestart = BOOTSTRAPPER_APPLY_RESTART_REQUIRED;
+        hr = S_OK;
+    }
+    else if (HRESULT_FROM_WIN32(ERROR_SUCCESS_REBOOT_INITIATED) == hr)
+    {
+        *pRestart = BOOTSTRAPPER_APPLY_RESTART_INITIATED;
+        hr = S_OK;
+    }
+
+    return hr;
+}
+
+static HRESULT OnMsiBeginTransaction(
+    __in BURN_ELEVATION_CHILD_MESSAGE_CONTEXT* pContext
+)
+{
+    UINT uResult = ERROR_SUCCESS;
+    HRESULT hr = S_OK;
+
+    pContext->hMsiTrns = NULL;
+    pContext->hMsiTrnsEvent = NULL;
+    uResult = MsiBeginTransaction(L"WiX", 0, &pContext->hMsiTrns, &pContext->hMsiTrnsEvent);
+    ExitOnWin32Error(uResult, hr, "Failed beginning an MSI transaction");
+
+LExit:
+    return hr;
+}
+
+static HRESULT OnMsiCommitTransaction(
+    __in BURN_ELEVATION_CHILD_MESSAGE_CONTEXT* pContext
+)
+{
+    UINT uResult = ERROR_SUCCESS;
+    HRESULT hr = S_OK;
+
+    uResult = MsiEndTransaction(MSITRANSACTIONSTATE_COMMIT);
+    ExitOnWin32Error(uResult, hr, "Failed committing an MSI transaction");
+
+LExit:
+    pContext->hMsiTrns = NULL;
+    pContext->hMsiTrnsEvent = NULL;
+    return hr;
+}
+
+static HRESULT OnMsiRollbackTransaction(
+    __in BURN_ELEVATION_CHILD_MESSAGE_CONTEXT* pContext
+) {
+    UINT uResult = ERROR_SUCCESS;
+    HRESULT hr = S_OK;
+
+    uResult = MsiEndTransaction(MSITRANSACTIONSTATE_ROLLBACK);
+    ExitOnWin32Error(uResult, hr, "Failed rolling back an MSI transaction");
+
+LExit:
+    pContext->hMsiTrns = NULL;
+    pContext->hMsiTrnsEvent = NULL;
+    return hr;
+}
+
+static HRESULT OnApplyInitialize(
+    __in BURN_VARIABLES* pVariables,
+    __in BURN_REGISTRATION* pRegistration,
+    __in HANDLE* phLock,
+    __in BOOL* pfDisabledWindowsUpdate,
+    __in BYTE* pbData,
+    __in DWORD cbData
+    )
+{
+    HRESULT hr = S_OK;
+    SIZE_T iData = 0;
+    DWORD dwAction = 0;
+    DWORD dwAUAction = 0;
+    DWORD dwTakeSystemRestorePoint = 0;
+    LPWSTR sczBundleName = NULL;
+
+    // Deserialize message data.
+    hr = BuffReadNumber(pbData, cbData, &iData, &dwAction);
+    ExitOnFailure(hr, "Failed to read action.");
+
+    hr = BuffReadNumber(pbData, cbData, &iData, &dwAUAction);
+    ExitOnFailure(hr, "Failed to read update action.");
+
+    hr = BuffReadNumber(pbData, cbData, &iData, &dwTakeSystemRestorePoint);
+    ExitOnFailure(hr, "Failed to read system restore point action.");
+
+    hr = VariableDeserialize(pVariables, FALSE, pbData, cbData, &iData);
+    ExitOnFailure(hr, "Failed to read variables.");
+
+    // Initialize.
+    hr = ApplyLock(TRUE, phLock);
+    ExitOnFailure(hr, "Failed to acquire lock due to setup in other session.");
+
+    // Reset and reload the related bundles.
+    RelatedBundlesUninitialize(&pRegistration->relatedBundles);
+
+    hr = RelatedBundlesInitializeForScope(TRUE, pRegistration, &pRegistration->relatedBundles);
+    ExitOnFailure(hr, "Failed to initialize per-machine related bundles.");
+
+    // Attempt to pause AU with best effort.
+    if (BURN_AU_PAUSE_ACTION_IFELEVATED == dwAUAction || BURN_AU_PAUSE_ACTION_IFELEVATED_NORESUME == dwAUAction)
+    {
+        LogId(REPORT_STANDARD, MSG_PAUSE_AU_STARTING);
+
+        hr = WuaPauseAutomaticUpdates();
+        if (FAILED(hr))
+        {
+            LogId(REPORT_STANDARD, MSG_FAILED_PAUSE_AU, hr);
+            hr = S_OK;
+        }
+        else
+        {
+            LogId(REPORT_STANDARD, MSG_PAUSE_AU_SUCCEEDED);
+            if (BURN_AU_PAUSE_ACTION_IFELEVATED == dwAUAction)
+            {
+                *pfDisabledWindowsUpdate = TRUE;
+            }
+        }
+    }
+
+    if (dwTakeSystemRestorePoint)
+    {
+        hr = VariableGetString(pVariables, BURN_BUNDLE_NAME, &sczBundleName);
+        if (FAILED(hr))
+        {
+            hr = S_OK;
+            ExitFunction();
+        }
+
+        LogId(REPORT_STANDARD, MSG_SYSTEM_RESTORE_POINT_STARTING);
+
+        BOOTSTRAPPER_ACTION action = static_cast<BOOTSTRAPPER_ACTION>(dwAction);
+        SRP_ACTION restoreAction = (BOOTSTRAPPER_ACTION_INSTALL == action) ? SRP_ACTION_INSTALL : (BOOTSTRAPPER_ACTION_UNINSTALL == action) ? SRP_ACTION_UNINSTALL : SRP_ACTION_MODIFY;
+        hr = SrpCreateRestorePoint(sczBundleName, restoreAction);
+        if (SUCCEEDED(hr))
+        {
+            LogId(REPORT_STANDARD, MSG_SYSTEM_RESTORE_POINT_SUCCEEDED);
+        }
+        else if (E_NOTIMPL == hr)
+        {
+            LogId(REPORT_STANDARD, MSG_SYSTEM_RESTORE_POINT_DISABLED);
+            hr = S_OK;
+        }
+        else if (FAILED(hr))
+        {
+            LogId(REPORT_STANDARD, MSG_SYSTEM_RESTORE_POINT_FAILED, hr);
+            hr = S_OK;
+        }
+    }
+
+LExit:
+    ReleaseStr(sczBundleName);
+    return hr;
+}
+
+static HRESULT OnApplyUninitialize(
+    __in HANDLE* phLock
+    )
+{
+    Assert(phLock);
+
+    // TODO: end system restore point.
+
+    if (*phLock)
+    {
+        ::ReleaseMutex(*phLock);
+        ::CloseHandle(*phLock);
+        *phLock = NULL;
+    }
+
+    return S_OK;
+}
+
+static HRESULT OnSessionBegin(
+    __in BURN_REGISTRATION* pRegistration,
+    __in BURN_VARIABLES* pVariables,
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in BYTE* pbData,
+    __in DWORD cbData
+    )
+{
+    HRESULT hr = S_OK;
+    SIZE_T iData = 0;
+    LPWSTR sczEngineWorkingPath = NULL;
+    DWORD dwRegistrationOperations = 0;
+    DWORD dwDependencyRegistrationAction = 0;
+    DWORD64 qwEstimatedSize = 0;
+
+    // Deserialize message data.
+    hr = BuffReadString(pbData, cbData, &iData, &sczEngineWorkingPath);
+    ExitOnFailure(hr, "Failed to read engine working path.");
+
+    hr = BuffReadString(pbData, cbData, &iData, &pRegistration->sczResumeCommandLine);
+    ExitOnFailure(hr, "Failed to read resume command line.");
+
+    hr = BuffReadNumber(pbData, cbData, &iData, (DWORD*)&pRegistration->fDisableResume);
+    ExitOnFailure(hr, "Failed to read resume flag.");
+
+    hr = BuffReadNumber(pbData, cbData, &iData, &dwRegistrationOperations);
+    ExitOnFailure(hr, "Failed to read registration operations.");
+
+    hr = BuffReadNumber(pbData, cbData, &iData, &dwDependencyRegistrationAction);
+    ExitOnFailure(hr, "Failed to read dependency registration action.");
+
+    hr = BuffReadNumber64(pbData, cbData, &iData, &qwEstimatedSize);
+    ExitOnFailure(hr, "Failed to read estimated size.");
+
+    hr = VariableDeserialize(pVariables, FALSE, pbData, cbData, &iData);
+    ExitOnFailure(hr, "Failed to read variables.");
+
+    // Begin session in per-machine process.
+    hr = RegistrationSessionBegin(sczEngineWorkingPath, pRegistration, pVariables, pUserExperience, dwRegistrationOperations, (BURN_DEPENDENCY_REGISTRATION_ACTION)dwDependencyRegistrationAction, qwEstimatedSize);
+    ExitOnFailure(hr, "Failed to begin registration session.");
+
+LExit:
+    ReleaseStr(sczEngineWorkingPath);
+
+    return hr;
+}
+
+static HRESULT OnSessionResume(
+    __in BURN_REGISTRATION* pRegistration,
+    __in BURN_VARIABLES* pVariables,
+    __in BYTE* pbData,
+    __in DWORD cbData
+    )
+{
+    HRESULT hr = S_OK;
+    SIZE_T iData = 0;
+
+    // Deserialize message data.
+    hr = BuffReadString(pbData, cbData, &iData, &pRegistration->sczResumeCommandLine);
+    ExitOnFailure(hr, "Failed to read resume command line.");
+
+    hr = BuffReadNumber(pbData, cbData, &iData, (DWORD*)&pRegistration->fDisableResume);
+    ExitOnFailure(hr, "Failed to read resume flag.");
+
+    hr = VariableDeserialize(pVariables, FALSE, pbData, cbData, &iData);
+    ExitOnFailure(hr, "Failed to read variables.");
+
+    // resume session in per-machine process
+    hr = RegistrationSessionResume(pRegistration, pVariables);
+    ExitOnFailure(hr, "Failed to resume registration session.");
+
+LExit:
+    return hr;
+}
+
+static HRESULT OnSessionEnd(
+    __in BURN_REGISTRATION* pRegistration,
+    __in BYTE* pbData,
+    __in DWORD cbData
+    )
+{
+    HRESULT hr = S_OK;
+    SIZE_T iData = 0;
+    DWORD dwResumeMode = 0;
+    DWORD dwRestart = 0;
+    DWORD dwDependencyRegistrationAction = 0;
+
+    // Deserialize message data.
+    hr = BuffReadNumber(pbData, cbData, &iData, &dwResumeMode);
+    ExitOnFailure(hr, "Failed to read resume mode enum.");
+
+    hr = BuffReadNumber(pbData, cbData, &iData, &dwRestart);
+    ExitOnFailure(hr, "Failed to read restart enum.");
+
+    hr = BuffReadNumber(pbData, cbData, &iData, &dwDependencyRegistrationAction);
+    ExitOnFailure(hr, "Failed to read dependency registration action.");
+
+    // suspend session in per-machine process
+    hr = RegistrationSessionEnd(pRegistration, (BURN_RESUME_MODE)dwResumeMode, (BOOTSTRAPPER_APPLY_RESTART)dwRestart, (BURN_DEPENDENCY_REGISTRATION_ACTION)dwDependencyRegistrationAction);
+    ExitOnFailure(hr, "Failed to suspend registration session.");
+
+LExit:
+    return hr;
+}
+
+static HRESULT OnSaveState(
+    __in BURN_REGISTRATION* pRegistration,
+    __in BYTE* pbData,
+    __in DWORD cbData
+    )
+{
+    HRESULT hr = S_OK;
+
+    // save state in per-machine process
+    hr = RegistrationSaveState(pRegistration, pbData, cbData);
+    ExitOnFailure(hr, "Failed to save state.");
+
+LExit:
+    return hr;
+}
+
+static HRESULT OnLayoutBundle(
+    __in_z LPCWSTR wzExecutableName,
+    __in BYTE* pbData,
+    __in DWORD cbData
+    )
+{
+    HRESULT hr = S_OK;
+    SIZE_T iData = 0;
+    LPWSTR sczLayoutDirectory = NULL;
+    LPWSTR sczUnverifiedPath = NULL;
+
+    // Deserialize message data.
+    hr = BuffReadString(pbData, cbData, &iData, &sczLayoutDirectory);
+    ExitOnFailure(hr, "Failed to read layout directory.");
+
+    hr = BuffReadString(pbData, cbData, &iData, &sczUnverifiedPath);
+    ExitOnFailure(hr, "Failed to read unverified bundle path.");
+
+    // Layout the bundle.
+    hr = CacheLayoutBundle(wzExecutableName, sczLayoutDirectory, sczUnverifiedPath);
+    ExitOnFailure(hr, "Failed to layout bundle from: %ls", sczUnverifiedPath);
+
+LExit:
+    ReleaseStr(sczUnverifiedPath);
+    ReleaseStr(sczLayoutDirectory);
+
+    return hr;
+}
+
+static HRESULT OnCacheOrLayoutContainerOrPayload(
+    __in BURN_CONTAINERS* pContainers,
+    __in BURN_PACKAGES* pPackages,
+    __in BURN_PAYLOADS* pPayloads,
+    __in BYTE* pbData,
+    __in DWORD cbData
+    )
+{
+    HRESULT hr = S_OK;
+    SIZE_T iData = 0;
+    LPWSTR scz = NULL;
+    BURN_CONTAINER* pContainer = NULL;
+    BURN_PACKAGE* pPackage = NULL;
+    BURN_PAYLOAD* pPayload = NULL;
+    LPWSTR sczLayoutDirectory = NULL;
+    LPWSTR sczUnverifiedPath = NULL;
+    BOOL fMove = FALSE;
+
+    // Deserialize message data.
+    hr = BuffReadString(pbData, cbData, &iData, &scz);
+    ExitOnFailure(hr, "Failed to read package id.");
+
+    if (scz && *scz)
+    {
+        hr = ContainerFindById(pContainers, scz, &pContainer);
+        ExitOnFailure(hr, "Failed to find container: %ls", scz);
+    }
+
+    hr = BuffReadString(pbData, cbData, &iData, &scz);
+    ExitOnFailure(hr, "Failed to read package id.");
+
+    if (scz && *scz)
+    {
+        hr = PackageFindById(pPackages, scz, &pPackage);
+        ExitOnFailure(hr, "Failed to find package: %ls", scz);
+    }
+
+    hr = BuffReadString(pbData, cbData, &iData, &scz);
+    ExitOnFailure(hr, "Failed to read payload id.");
+
+    if (scz && *scz)
+    {
+        hr = PayloadFindById(pPayloads, scz, &pPayload);
+        ExitOnFailure(hr, "Failed to find payload: %ls", scz);
+    }
+
+    hr = BuffReadString(pbData, cbData, &iData, &sczLayoutDirectory);
+    ExitOnFailure(hr, "Failed to read layout directory.");
+
+    hr = BuffReadString(pbData, cbData, &iData, &sczUnverifiedPath);
+    ExitOnFailure(hr, "Failed to read unverified path.");
+
+    hr = BuffReadNumber(pbData, cbData, &iData, (DWORD*)&fMove);
+    ExitOnFailure(hr, "Failed to read move flag.");
+
+    // Layout payload.
+    if (sczLayoutDirectory && *sczLayoutDirectory)
+    {
+        if (pContainer)
+        {
+            Assert(!pPackage);
+            Assert(!pPayload);
+
+            hr = CacheLayoutContainer(pContainer, sczLayoutDirectory, sczUnverifiedPath, fMove);
+            ExitOnFailure(hr, "Failed to layout container from: %ls to %ls", sczUnverifiedPath, sczLayoutDirectory);
+        }
+        else
+        {
+            hr = CacheLayoutPayload(pPayload, sczLayoutDirectory, sczUnverifiedPath, fMove);
+            ExitOnFailure(hr, "Failed to layout payload from: %ls to %ls", sczUnverifiedPath, sczLayoutDirectory);
+        }
+    }
+    else if (pPackage) // complete payload.
+    {
+        Assert(!pContainer);
+
+        hr = CacheCompletePayload(pPackage->fPerMachine, pPayload, pPackage->sczCacheId, sczUnverifiedPath, fMove);
+        ExitOnFailure(hr, "Failed to cache payload: %ls", pPayload->sczKey);
+    }
+    else
+    {
+        hr = E_INVALIDARG;
+        ExitOnRootFailure(hr, "Invalid data passed to cache or layout payload.");
+    }
+
+LExit:
+    ReleaseStr(sczUnverifiedPath);
+    ReleaseStr(sczLayoutDirectory);
+    ReleaseStr(scz);
+
+    return hr;
+}
+
+static void OnCacheCleanup(
+    __in_z LPCWSTR wzBundleId
+    )
+{
+    CacheCleanup(TRUE, wzBundleId);
+}
+
+static HRESULT OnProcessDependentRegistration(
+    __in const BURN_REGISTRATION* pRegistration,
+    __in BYTE* pbData,
+    __in DWORD cbData
+    )
+{
+    HRESULT hr = S_OK;
+    SIZE_T iData = 0;
+    BURN_DEPENDENT_REGISTRATION_ACTION action = { };
+
+    // Deserialize message data.
+    hr = BuffReadNumber(pbData, cbData, &iData, (DWORD*)&action.type);
+    ExitOnFailure(hr, "Failed to read action type.");
+
+    hr = BuffReadString(pbData, cbData, &iData, &action.sczBundleId);
+    ExitOnFailure(hr, "Failed to read bundle id.");
+
+    hr = BuffReadString(pbData, cbData, &iData, &action.sczDependentProviderKey);
+    ExitOnFailure(hr, "Failed to read dependent provider key.");
+
+    // Execute the registration action.
+    hr = DependencyProcessDependentRegistration(pRegistration, &action);
+    ExitOnFailure(hr, "Failed to execute dependent registration action for provider key: %ls", action.sczDependentProviderKey);
+
+LExit:
+    // TODO: do the right thing here.
+    //DependencyUninitializeRegistrationAction(&action);
+    ReleaseStr(action.sczDependentProviderKey);
+    ReleaseStr(action.sczBundleId)
+
+    return hr;
+}
+
+static HRESULT OnExecuteExePackage(
+    __in HANDLE hPipe,
+    __in BURN_PACKAGES* pPackages,
+    __in BURN_RELATED_BUNDLES* pRelatedBundles,
+    __in BURN_VARIABLES* pVariables,
+    __in BYTE* pbData,
+    __in DWORD cbData
+    )
+{
+    HRESULT hr = S_OK;
+    SIZE_T iData = 0;
+    LPWSTR sczPackage = NULL;
+    DWORD dwRollback = 0;
+    BURN_EXECUTE_ACTION executeAction = { };
+    LPWSTR sczIgnoreDependencies = NULL;
+    LPWSTR sczAncestors = NULL;
+    BOOTSTRAPPER_APPLY_RESTART exeRestart = BOOTSTRAPPER_APPLY_RESTART_NONE;
+
+    executeAction.type = BURN_EXECUTE_ACTION_TYPE_EXE_PACKAGE;
+
+    // Deserialize message data.
+    hr = BuffReadString(pbData, cbData, &iData, &sczPackage);
+    ExitOnFailure(hr, "Failed to read EXE package id.");
+
+    hr = BuffReadNumber(pbData, cbData, &iData, (DWORD*)&executeAction.exePackage.action);
+    ExitOnFailure(hr, "Failed to read action.");
+
+    hr = BuffReadNumber(pbData, cbData, &iData, &dwRollback);
+    ExitOnFailure(hr, "Failed to read rollback.");
+
+    hr = BuffReadString(pbData, cbData, &iData, &sczIgnoreDependencies);
+    ExitOnFailure(hr, "Failed to read the list of dependencies to ignore.");
+
+    hr = BuffReadString(pbData, cbData, &iData, &sczAncestors);
+    ExitOnFailure(hr, "Failed to read the list of ancestors.");
+
+    hr = VariableDeserialize(pVariables, FALSE, pbData, cbData, &iData);
+    ExitOnFailure(hr, "Failed to read variables.");
+
+    hr = PackageFindById(pPackages, sczPackage, &executeAction.exePackage.pPackage);
+    if (E_NOTFOUND == hr)
+    {
+        hr = PackageFindRelatedById(pRelatedBundles, sczPackage, &executeAction.exePackage.pPackage);
+    }
+    ExitOnFailure(hr, "Failed to find package: %ls", sczPackage);
+
+    // Pass the list of dependencies to ignore, if any, to the related bundle.
+    if (sczIgnoreDependencies && *sczIgnoreDependencies)
+    {
+        hr = StrAllocString(&executeAction.exePackage.sczIgnoreDependencies, sczIgnoreDependencies, 0);
+        ExitOnFailure(hr, "Failed to allocate the list of dependencies to ignore.");
+    }
+
+    // Pass the list of ancestors, if any, to the related bundle.
+    if (sczAncestors && *sczAncestors)
+    {
+        hr = StrAllocString(&executeAction.exePackage.sczAncestors, sczAncestors, 0);
+        ExitOnFailure(hr, "Failed to allocate the list of ancestors.");
+    }
+
+    // Execute EXE package.
+    hr = ExeEngineExecutePackage(&executeAction, pVariables, static_cast<BOOL>(dwRollback), GenericExecuteMessageHandler, hPipe, &exeRestart);
+    ExitOnFailure(hr, "Failed to execute EXE package.");
+
+LExit:
+    ReleaseStr(sczAncestors);
+    ReleaseStr(sczIgnoreDependencies);
+    ReleaseStr(sczPackage);
+    PlanUninitializeExecuteAction(&executeAction);
+
+    if (SUCCEEDED(hr))
+    {
+        if (BOOTSTRAPPER_APPLY_RESTART_REQUIRED == exeRestart)
+        {
+            hr = HRESULT_FROM_WIN32(ERROR_SUCCESS_REBOOT_REQUIRED);
+        }
+        else if (BOOTSTRAPPER_APPLY_RESTART_INITIATED == exeRestart)
+        {
+            hr = HRESULT_FROM_WIN32(ERROR_SUCCESS_REBOOT_INITIATED);
+        }
+    }
+
+    return hr;
+}
+
+static HRESULT OnExecuteMsiPackage(
+    __in HANDLE hPipe,
+    __in BURN_PACKAGES* pPackages,
+    __in BURN_VARIABLES* pVariables,
+    __in BYTE* pbData,
+    __in DWORD cbData
+    )
+{
+    HRESULT hr = S_OK;
+    SIZE_T iData = 0;
+    LPWSTR sczPackage = NULL;
+    HWND hwndParent = NULL;
+    BOOL fRollback = 0;
+    BURN_EXECUTE_ACTION executeAction = { };
+    BOOTSTRAPPER_APPLY_RESTART msiRestart = BOOTSTRAPPER_APPLY_RESTART_NONE;
+
+    executeAction.type = BURN_EXECUTE_ACTION_TYPE_MSI_PACKAGE;
+
+    // Deserialize message data.
+    hr = BuffReadString(pbData, cbData, &iData, &sczPackage);
+    ExitOnFailure(hr, "Failed to read MSI package id.");
+
+    hr = PackageFindById(pPackages, sczPackage, &executeAction.msiPackage.pPackage);
+    ExitOnFailure(hr, "Failed to find package: %ls", sczPackage);
+
+    hr = BuffReadNumber(pbData, cbData, &iData, (DWORD*)&hwndParent);
+    ExitOnFailure(hr, "Failed to read parent hwnd.");
+
+    hr = BuffReadString(pbData, cbData, &iData, &executeAction.msiPackage.sczLogPath);
+    ExitOnFailure(hr, "Failed to read package log.");
+
+    hr = BuffReadNumber(pbData, cbData, &iData, (DWORD*)&executeAction.msiPackage.uiLevel);
+    ExitOnFailure(hr, "Failed to read UI level.");
+
+    hr = BuffReadNumber(pbData, cbData, &iData, (DWORD*)&executeAction.msiPackage.action);
+    ExitOnFailure(hr, "Failed to read action.");
+
+    // Read feature actions.
+    if (executeAction.msiPackage.pPackage->Msi.cFeatures)
+    {
+        executeAction.msiPackage.rgFeatures = (BOOTSTRAPPER_FEATURE_ACTION*)MemAlloc(executeAction.msiPackage.pPackage->Msi.cFeatures * sizeof(BOOTSTRAPPER_FEATURE_ACTION), TRUE);
+        ExitOnNull(executeAction.msiPackage.rgFeatures, hr, E_OUTOFMEMORY, "Failed to allocate memory for feature actions.");
+
+        for (DWORD i = 0; i < executeAction.msiPackage.pPackage->Msi.cFeatures; ++i)
+        {
+            hr = BuffReadNumber(pbData, cbData, &iData, (DWORD*)&executeAction.msiPackage.rgFeatures[i]);
+            ExitOnFailure(hr, "Failed to read feature action.");
+        }
+    }
+
+    // Read slipstream patches actions.
+    if (executeAction.msiPackage.pPackage->Msi.cSlipstreamMspPackages)
+    {
+        executeAction.msiPackage.rgSlipstreamPatches = (BOOTSTRAPPER_ACTION_STATE*)MemAlloc(executeAction.msiPackage.pPackage->Msi.cSlipstreamMspPackages * sizeof(BOOTSTRAPPER_ACTION_STATE), TRUE);
+        ExitOnNull(executeAction.msiPackage.rgSlipstreamPatches, hr, E_OUTOFMEMORY, "Failed to allocate memory for slipstream patch actions.");
+        
+        for (DWORD i = 0; i < executeAction.msiPackage.pPackage->Msi.cSlipstreamMspPackages; ++i)
+        {
+            hr = BuffReadNumber(pbData, cbData, &iData, (DWORD*)&executeAction.msiPackage.rgSlipstreamPatches[i]);
+            ExitOnFailure(hr, "Failed to read slipstream action.");
+        }
+    }
+
+    hr = VariableDeserialize(pVariables, FALSE, pbData, cbData, &iData);
+    ExitOnFailure(hr, "Failed to read variables.");
+
+    hr = BuffReadNumber(pbData, cbData, &iData, (DWORD*)&fRollback);
+    ExitOnFailure(hr, "Failed to read rollback flag.");
+
+    // Execute MSI package.
+    hr = MsiEngineExecutePackage(hwndParent, &executeAction, pVariables, fRollback, MsiExecuteMessageHandler, hPipe, &msiRestart);
+    ExitOnFailure(hr, "Failed to execute MSI package.");
+
+LExit:
+    ReleaseStr(sczPackage);
+    PlanUninitializeExecuteAction(&executeAction);
+
+    if (SUCCEEDED(hr))
+    {
+        if (BOOTSTRAPPER_APPLY_RESTART_REQUIRED == msiRestart)
+        {
+            hr = HRESULT_FROM_WIN32(ERROR_SUCCESS_REBOOT_REQUIRED);
+        }
+        else if (BOOTSTRAPPER_APPLY_RESTART_INITIATED == msiRestart)
+        {
+            hr = HRESULT_FROM_WIN32(ERROR_SUCCESS_REBOOT_INITIATED);
+        }
+    }
+
+    return hr;
+}
+
+static HRESULT OnExecuteMspPackage(
+    __in HANDLE hPipe,
+    __in BURN_PACKAGES* pPackages,
+    __in BURN_VARIABLES* pVariables,
+    __in BYTE* pbData,
+    __in DWORD cbData
+    )
+{
+    HRESULT hr = S_OK;
+    SIZE_T iData = 0;
+    LPWSTR sczPackage = NULL;
+    HWND hwndParent = NULL;
+    BOOL fRollback = 0;
+    BURN_EXECUTE_ACTION executeAction = { };
+    BOOTSTRAPPER_APPLY_RESTART restart = BOOTSTRAPPER_APPLY_RESTART_NONE;
+
+    executeAction.type = BURN_EXECUTE_ACTION_TYPE_MSP_TARGET;
+
+    // Deserialize message data.
+    hr = BuffReadString(pbData, cbData, &iData, &sczPackage);
+    ExitOnFailure(hr, "Failed to read MSP package id.");
+
+    hr = PackageFindById(pPackages, sczPackage, &executeAction.mspTarget.pPackage);
+    ExitOnFailure(hr, "Failed to find package: %ls", sczPackage);
+
+    hr = BuffReadNumber(pbData, cbData, &iData, (DWORD*)&hwndParent);
+    ExitOnFailure(hr, "Failed to read parent hwnd.");
+
+    executeAction.mspTarget.fPerMachineTarget = TRUE; // we're in the elevated process, clearly we're targeting a per-machine product.
+
+    hr = BuffReadString(pbData, cbData, &iData, &executeAction.mspTarget.sczTargetProductCode);
+    ExitOnFailure(hr, "Failed to read target product code.");
+
+    hr = BuffReadString(pbData, cbData, &iData, &executeAction.mspTarget.sczLogPath);
+    ExitOnFailure(hr, "Failed to read package log.");
+
+    hr = BuffReadNumber(pbData, cbData, &iData, (DWORD*)&executeAction.mspTarget.uiLevel);
+    ExitOnFailure(hr, "Failed to read UI level.");
+
+    hr = BuffReadNumber(pbData, cbData, &iData, (DWORD*)&executeAction.mspTarget.action);
+    ExitOnFailure(hr, "Failed to read action.");
+
+    hr = BuffReadNumber(pbData, cbData, &iData, (DWORD*)&executeAction.mspTarget.cOrderedPatches);
+    ExitOnFailure(hr, "Failed to read count of ordered patches.");
+
+    if (executeAction.mspTarget.cOrderedPatches)
+    {
+        executeAction.mspTarget.rgOrderedPatches = (BURN_ORDERED_PATCHES*)MemAlloc(executeAction.mspTarget.cOrderedPatches * sizeof(BURN_ORDERED_PATCHES), TRUE);
+        ExitOnNull(executeAction.mspTarget.rgOrderedPatches, hr, E_OUTOFMEMORY, "Failed to allocate memory for ordered patches.");
+
+        for (DWORD i = 0; i < executeAction.mspTarget.cOrderedPatches; ++i)
+        {
+            hr = BuffReadNumber(pbData, cbData, &iData, &executeAction.mspTarget.rgOrderedPatches[i].dwOrder);
+            ExitOnFailure(hr, "Failed to read ordered patch order number.");
+
+            hr = BuffReadString(pbData, cbData, &iData, &sczPackage);
+            ExitOnFailure(hr, "Failed to read ordered patch package id.");
+
+            hr = PackageFindById(pPackages, sczPackage, &executeAction.mspTarget.rgOrderedPatches[i].pPackage);
+            ExitOnFailure(hr, "Failed to find ordered patch package: %ls", sczPackage);
+        }
+    }
+
+    hr = VariableDeserialize(pVariables, FALSE, pbData, cbData, &iData);
+    ExitOnFailure(hr, "Failed to read variables.");
+
+    hr = BuffReadNumber(pbData, cbData, &iData, (DWORD*)&fRollback);
+    ExitOnFailure(hr, "Failed to read rollback flag.");
+
+    // Execute MSP package.
+    hr = MspEngineExecutePackage(hwndParent, &executeAction, pVariables, fRollback, MsiExecuteMessageHandler, hPipe, &restart);
+    ExitOnFailure(hr, "Failed to execute MSP package.");
+
+LExit:
+    ReleaseStr(sczPackage);
+    PlanUninitializeExecuteAction(&executeAction);
+
+    if (SUCCEEDED(hr))
+    {
+        if (BOOTSTRAPPER_APPLY_RESTART_REQUIRED == restart)
+        {
+            hr = HRESULT_FROM_WIN32(ERROR_SUCCESS_REBOOT_REQUIRED);
+        }
+        else if (BOOTSTRAPPER_APPLY_RESTART_INITIATED == restart)
+        {
+            hr = HRESULT_FROM_WIN32(ERROR_SUCCESS_REBOOT_INITIATED);
+        }
+    }
+
+    return hr;
+}
+
+static HRESULT OnExecuteMsuPackage(
+    __in HANDLE hPipe,
+    __in BURN_PACKAGES* pPackages,
+    __in BURN_VARIABLES* pVariables,
+    __in BYTE* pbData,
+    __in DWORD cbData
+    )
+{
+    HRESULT hr = S_OK;
+    SIZE_T iData = 0;
+    LPWSTR sczPackage = NULL;
+    DWORD dwRollback = 0;
+    DWORD dwStopWusaService = 0;
+    BURN_EXECUTE_ACTION executeAction = { };
+    BOOTSTRAPPER_APPLY_RESTART restart = BOOTSTRAPPER_APPLY_RESTART_NONE;
+
+    executeAction.type = BURN_EXECUTE_ACTION_TYPE_MSU_PACKAGE;
+
+    // Deserialize message data.
+    hr = BuffReadString(pbData, cbData, &iData, &sczPackage);
+    ExitOnFailure(hr, "Failed to read MSU package id.");
+
+    hr = BuffReadString(pbData, cbData, &iData, &executeAction.msuPackage.sczLogPath);
+    ExitOnFailure(hr, "Failed to read package log.");
+
+    hr = BuffReadNumber(pbData, cbData, &iData, reinterpret_cast<DWORD*>(&executeAction.msuPackage.action));
+    ExitOnFailure(hr, "Failed to read action.");
+
+    hr = BuffReadNumber(pbData, cbData, &iData, &dwRollback);
+    ExitOnFailure(hr, "Failed to read rollback.");
+
+    hr = BuffReadNumber(pbData, cbData, &iData, &dwStopWusaService);
+    ExitOnFailure(hr, "Failed to read StopWusaService.");
+
+    hr = PackageFindById(pPackages, sczPackage, &executeAction.msuPackage.pPackage);
+    ExitOnFailure(hr, "Failed to find package: %ls", sczPackage);
+
+    // execute MSU package
+    hr = MsuEngineExecutePackage(&executeAction, pVariables, static_cast<BOOL>(dwRollback), static_cast<BOOL>(dwStopWusaService), GenericExecuteMessageHandler, hPipe, &restart);
+    ExitOnFailure(hr, "Failed to execute MSU package.");
+
+LExit:
+    ReleaseStr(sczPackage);
+    PlanUninitializeExecuteAction(&executeAction);
+
+    if (SUCCEEDED(hr))
+    {
+        if (BOOTSTRAPPER_APPLY_RESTART_REQUIRED == restart)
+        {
+            hr = HRESULT_FROM_WIN32(ERROR_SUCCESS_REBOOT_REQUIRED);
+        }
+        else if (BOOTSTRAPPER_APPLY_RESTART_INITIATED == restart)
+        {
+            hr = HRESULT_FROM_WIN32(ERROR_SUCCESS_REBOOT_INITIATED);
+        }
+    }
+
+    return hr;
+}
+
+static HRESULT OnExecutePackageProviderAction(
+    __in BURN_PACKAGES* pPackages,
+    __in BURN_RELATED_BUNDLES* pRelatedBundles,
+    __in BYTE* pbData,
+    __in DWORD cbData
+    )
+{
+    HRESULT hr = S_OK;
+    SIZE_T iData = 0;
+    LPWSTR sczPackage = NULL;
+    BURN_EXECUTE_ACTION executeAction = { };
+
+    executeAction.type = BURN_EXECUTE_ACTION_TYPE_PACKAGE_PROVIDER;
+
+    // Deserialize the message data.
+    hr = BuffReadString(pbData, cbData, &iData, &sczPackage);
+    ExitOnFailure(hr, "Failed to read package id from message buffer.");
+
+    hr = BuffReadNumber(pbData, cbData, &iData, reinterpret_cast<DWORD*>(&executeAction.packageProvider.action));
+    ExitOnFailure(hr, "Failed to read action.");
+
+    // Find the package again.
+    hr = PackageFindById(pPackages, sczPackage, &executeAction.packageProvider.pPackage);
+    if (E_NOTFOUND == hr)
+    {
+        hr = PackageFindRelatedById(pRelatedBundles, sczPackage, &executeAction.packageProvider.pPackage);
+    }
+    ExitOnFailure(hr, "Failed to find package: %ls", sczPackage);
+
+    // Execute the package provider action.
+    hr = DependencyExecutePackageProviderAction(&executeAction);
+    ExitOnFailure(hr, "Failed to execute package provider action.");
+
+LExit:
+    ReleaseStr(sczPackage);
+    PlanUninitializeExecuteAction(&executeAction);
+
+    return hr;
+}
+
+static HRESULT OnExecutePackageDependencyAction(
+    __in BURN_PACKAGES* pPackages,
+    __in BURN_RELATED_BUNDLES* pRelatedBundles,
+    __in BYTE* pbData,
+    __in DWORD cbData
+    )
+{
+    HRESULT hr = S_OK;
+    SIZE_T iData = 0;
+    LPWSTR sczPackage = NULL;
+    BURN_EXECUTE_ACTION executeAction = { };
+
+    executeAction.type = BURN_EXECUTE_ACTION_TYPE_PACKAGE_DEPENDENCY;
+
+    // Deserialize the message data.
+    hr = BuffReadString(pbData, cbData, &iData, &sczPackage);
+    ExitOnFailure(hr, "Failed to read package id from message buffer.");
+
+    hr = BuffReadString(pbData, cbData, &iData, &executeAction.packageDependency.sczBundleProviderKey);
+    ExitOnFailure(hr, "Failed to read bundle dependency key from message buffer.");
+
+    hr = BuffReadNumber(pbData, cbData, &iData, reinterpret_cast<DWORD*>(&executeAction.packageDependency.action));
+    ExitOnFailure(hr, "Failed to read action.");
+
+    // Find the package again.
+    hr = PackageFindById(pPackages, sczPackage, &executeAction.packageDependency.pPackage);
+    if (E_NOTFOUND == hr)
+    {
+        hr = PackageFindRelatedById(pRelatedBundles, sczPackage, &executeAction.packageDependency.pPackage);
+    }
+    ExitOnFailure(hr, "Failed to find package: %ls", sczPackage);
+
+    // Execute the package dependency action.
+    hr = DependencyExecutePackageDependencyAction(TRUE, &executeAction);
+    ExitOnFailure(hr, "Failed to execute package dependency action.");
+
+LExit:
+    ReleaseStr(sczPackage);
+    PlanUninitializeExecuteAction(&executeAction);
+
+    return hr;
+}
+
+static HRESULT OnLoadCompatiblePackage(
+    __in BURN_PACKAGES* pPackages,
+    __in BYTE* pbData,
+    __in DWORD cbData
+    )
+{
+    HRESULT hr = S_OK;
+    SIZE_T iData = 0;
+    LPWSTR sczPackage = NULL;
+    BURN_EXECUTE_ACTION executeAction = { };
+
+    executeAction.type = BURN_EXECUTE_ACTION_TYPE_COMPATIBLE_PACKAGE;
+
+    // Deserialize the message data.
+    hr = BuffReadString(pbData, cbData, &iData, &sczPackage);
+    ExitOnFailure(hr, "Failed to read package id from message buffer.");
+
+    // Find the reference package.
+    hr = PackageFindById(pPackages, sczPackage, &executeAction.compatiblePackage.pReferencePackage);
+    ExitOnFailure(hr, "Failed to find package: %ls", sczPackage);
+
+    hr = BuffReadString(pbData, cbData, &iData, &executeAction.compatiblePackage.sczInstalledProductCode);
+    ExitOnFailure(hr, "Failed to read installed ProductCode from message buffer.");
+
+    hr = BuffReadNumber64(pbData, cbData, &iData, &executeAction.compatiblePackage.qwInstalledVersion);
+    ExitOnFailure(hr, "Failed to read installed version from message buffer.");
+
+    // Copy the installed data to the reference package.
+    hr = StrAllocString(&executeAction.compatiblePackage.pReferencePackage->Msi.sczInstalledProductCode, executeAction.compatiblePackage.sczInstalledProductCode, 0);
+    ExitOnFailure(hr, "Failed to copy installed ProductCode.");
+
+    executeAction.compatiblePackage.pReferencePackage->Msi.qwInstalledVersion = executeAction.compatiblePackage.qwInstalledVersion;
+
+    // Load the compatible package and add it to the list.
+    hr = MsiEngineAddCompatiblePackage(pPackages, executeAction.compatiblePackage.pReferencePackage, NULL);
+    ExitOnFailure(hr, "Failed to load compatible package.");
+
+LExit:
+    ReleaseStr(sczPackage);
+    PlanUninitializeExecuteAction(&executeAction);
+
+    return hr;
+}
+
+static int GenericExecuteMessageHandler(
+    __in GENERIC_EXECUTE_MESSAGE* pMessage,
+    __in LPVOID pvContext
+    )
+{
+    HRESULT hr = S_OK;
+    int nResult = IDOK;
+    HANDLE hPipe = (HANDLE)pvContext;
+    BYTE* pbData = NULL;
+    SIZE_T cbData = 0;
+    DWORD dwMessage = 0;
+
+    hr = BuffWriteNumber(&pbData, &cbData, pMessage->dwAllowedResults);
+    ExitOnFailure(hr, "Failed to write UI flags.");
+
+    switch(pMessage->type)
+    {
+    case GENERIC_EXECUTE_MESSAGE_PROGRESS:
+        // serialize message data
+        hr = BuffWriteNumber(&pbData, &cbData, pMessage->progress.dwPercentage);
+        ExitOnFailure(hr, "Failed to write progress percentage to message buffer.");
+
+        dwMessage = BURN_ELEVATION_MESSAGE_TYPE_EXECUTE_PROGRESS;
+        break;
+
+    case GENERIC_EXECUTE_MESSAGE_ERROR:
+        // serialize message data
+        hr = BuffWriteNumber(&pbData, &cbData, pMessage->error.dwErrorCode);
+        ExitOnFailure(hr, "Failed to write error code to message buffer.");
+
+        hr = BuffWriteString(&pbData, &cbData, pMessage->error.wzMessage);
+        ExitOnFailure(hr, "Failed to write message to message buffer.");
+
+        dwMessage = BURN_ELEVATION_MESSAGE_TYPE_EXECUTE_ERROR;
+        break;
+
+    case GENERIC_EXECUTE_MESSAGE_FILES_IN_USE:
+        hr = BuffWriteNumber(&pbData, &cbData, pMessage->filesInUse.cFiles);
+        ExitOnFailure(hr, "Failed to count of files in use to message buffer.");
+
+        for (DWORD i = 0; i < pMessage->filesInUse.cFiles; ++i)
+        {
+            hr = BuffWriteString(&pbData, &cbData, pMessage->filesInUse.rgwzFiles[i]);
+            ExitOnFailure(hr, "Failed to write file in use to message buffer.");
+        }
+
+        dwMessage = BURN_ELEVATION_MESSAGE_TYPE_EXECUTE_FILES_IN_USE;
+        break;
+    }
+
+    // send message
+    hr = PipeSendMessage(hPipe, dwMessage, pbData, cbData, NULL, NULL, reinterpret_cast<DWORD*>(&nResult));
+    ExitOnFailure(hr, "Failed to send message to per-user process.");
+
+LExit:
+    ReleaseBuffer(pbData);
+
+    return nResult;
+}
+
+static int MsiExecuteMessageHandler(
+    __in WIU_MSI_EXECUTE_MESSAGE* pMessage,
+    __in_opt LPVOID pvContext
+    )
+{
+    HRESULT hr = S_OK;
+    int nResult = IDOK;
+    HANDLE hPipe = (HANDLE)pvContext;
+    BYTE* pbData = NULL;
+    SIZE_T cbData = 0;
+    DWORD dwMessage = 0;
+
+    // Always send any extra data via the struct first.
+    hr = BuffWriteNumber(&pbData, &cbData, pMessage->cData);
+    ExitOnFailure(hr, "Failed to write MSI data count to message buffer.");
+
+    for (DWORD i = 0; i < pMessage->cData; ++i)
+    {
+        hr = BuffWriteString(&pbData, &cbData, pMessage->rgwzData[i]);
+        ExitOnFailure(hr, "Failed to write MSI data to message buffer.");
+    }
+
+    hr = BuffWriteNumber(&pbData, &cbData, pMessage->dwAllowedResults);
+    ExitOnFailure(hr, "Failed to write UI flags.");
+
+    switch (pMessage->type)
+    {
+    case WIU_MSI_EXECUTE_MESSAGE_PROGRESS:
+        // serialize message data
+        hr = BuffWriteNumber(&pbData, &cbData, pMessage->progress.dwPercentage);
+        ExitOnFailure(hr, "Failed to write progress percentage to message buffer.");
+
+        // set message id
+        dwMessage = BURN_ELEVATION_MESSAGE_TYPE_EXECUTE_PROGRESS;
+        break;
+
+    case WIU_MSI_EXECUTE_MESSAGE_ERROR:
+        // serialize message data
+        hr = BuffWriteNumber(&pbData, &cbData, pMessage->error.dwErrorCode);
+        ExitOnFailure(hr, "Failed to write error code to message buffer.");
+
+        hr = BuffWriteString(&pbData, &cbData, pMessage->error.wzMessage);
+        ExitOnFailure(hr, "Failed to write message to message buffer.");
+
+        // set message id
+        dwMessage = BURN_ELEVATION_MESSAGE_TYPE_EXECUTE_ERROR;
+        break;
+
+    case WIU_MSI_EXECUTE_MESSAGE_MSI_MESSAGE:
+        // serialize message data
+        hr = BuffWriteNumber(&pbData, &cbData, (DWORD)pMessage->msiMessage.mt);
+        ExitOnFailure(hr, "Failed to write MSI message type to message buffer.");
+
+        hr = BuffWriteString(&pbData, &cbData, pMessage->msiMessage.wzMessage);
+        ExitOnFailure(hr, "Failed to write message to message buffer.");
+
+        // set message id
+        dwMessage = BURN_ELEVATION_MESSAGE_TYPE_EXECUTE_MSI_MESSAGE;
+        break;
+
+    case WIU_MSI_EXECUTE_MESSAGE_MSI_FILES_IN_USE:
+        // NOTE: we do not serialize other message data here because all the "files in use" are in the data above.
+
+        // set message id
+        dwMessage = BURN_ELEVATION_MESSAGE_TYPE_EXECUTE_FILES_IN_USE;
+        break;
+
+    default:
+        hr = E_UNEXPECTED;
+        ExitOnFailure(hr, "Invalid message type: %d", pMessage->type);
+    }
+
+    // send message
+    hr = PipeSendMessage(hPipe, dwMessage, pbData, cbData, NULL, NULL, (DWORD*)&nResult);
+    ExitOnFailure(hr, "Failed to send message to per-machine process.");
+
+LExit:
+    ReleaseBuffer(pbData);
+
+    return nResult;
+}
+
+static HRESULT OnCleanPackage(
+    __in BURN_PACKAGES* pPackages,
+    __in BYTE* pbData,
+    __in DWORD cbData
+    )
+{
+    HRESULT hr = S_OK;
+    SIZE_T iData = 0;
+    LPWSTR sczPackage = NULL;
+    BURN_PACKAGE* pPackage = NULL;
+
+    // Deserialize message data.
+    hr = BuffReadString(pbData, cbData, &iData, &sczPackage);
+    ExitOnFailure(hr, "Failed to read package id.");
+
+    hr = PackageFindById(pPackages, sczPackage, &pPackage);
+    ExitOnFailure(hr, "Failed to find package: %ls", sczPackage);
+
+    // Remove the package from the cache.
+    hr = CacheRemovePackage(TRUE, pPackage->sczId, pPackage->sczCacheId);
+    ExitOnFailure(hr, "Failed to remove from cache package: %ls", pPackage->sczId);
+
+LExit:
+    ReleaseStr(sczPackage);
+    return hr;
+}
+
+static HRESULT OnLaunchApprovedExe(
+    __in HANDLE hPipe,
+    __in BURN_APPROVED_EXES* pApprovedExes,
+    __in BURN_VARIABLES* pVariables,
+    __in BYTE* pbData,
+    __in DWORD cbData
+    )
+{
+    HRESULT hr = S_OK;
+    SIZE_T iData = 0;
+    BURN_LAUNCH_APPROVED_EXE* pLaunchApprovedExe = NULL;
+    BURN_APPROVED_EXE* pApprovedExe = NULL;
+    REGSAM samDesired = KEY_QUERY_VALUE;
+    HKEY hKey = NULL;
+    DWORD dwProcessId = 0;
+    BYTE* pbSendData = NULL;
+    SIZE_T cbSendData = 0;
+    DWORD dwResult = 0;
+
+    pLaunchApprovedExe = (BURN_LAUNCH_APPROVED_EXE*)MemAlloc(sizeof(BURN_LAUNCH_APPROVED_EXE), TRUE);
+
+    // Deserialize message data.
+    hr = BuffReadString(pbData, cbData, &iData, &pLaunchApprovedExe->sczId);
+    ExitOnFailure(hr, "Failed to read approved exe id.");
+
+    hr = BuffReadString(pbData, cbData, &iData, &pLaunchApprovedExe->sczArguments);
+    ExitOnFailure(hr, "Failed to read approved exe arguments.");
+
+    hr = BuffReadNumber(pbData, cbData, &iData, &pLaunchApprovedExe->dwWaitForInputIdleTimeout);
+    ExitOnFailure(hr, "Failed to read approved exe WaitForInputIdle timeout.");
+
+    hr = ApprovedExesFindById(pApprovedExes, pLaunchApprovedExe->sczId, &pApprovedExe);
+    ExitOnFailure(hr, "The per-user process requested unknown approved exe with id: %ls", pLaunchApprovedExe->sczId);
+
+    LogId(REPORT_STANDARD, MSG_LAUNCH_APPROVED_EXE_SEARCH, pApprovedExe->sczKey, pApprovedExe->sczValueName ? pApprovedExe->sczValueName : L"", pApprovedExe->fWin64 ? L"yes" : L"no");
+
+    if (pApprovedExe->fWin64)
+    {
+        samDesired |= KEY_WOW64_64KEY;
+    }
+
+    hr = RegOpen(HKEY_LOCAL_MACHINE, pApprovedExe->sczKey, samDesired, &hKey);
+    ExitOnFailure(hr, "Failed to open the registry key for the approved exe path.");
+
+    hr = RegReadString(hKey, pApprovedExe->sczValueName, &pLaunchApprovedExe->sczExecutablePath);
+    ExitOnFailure(hr, "Failed to read the value for the approved exe path.");
+
+    hr = ApprovedExesVerifySecureLocation(pVariables, pLaunchApprovedExe);
+    ExitOnFailure(hr, "Failed to verify the executable path is in a secure location: %ls", pLaunchApprovedExe->sczExecutablePath);
+    if (S_FALSE == hr)
+    {
+        LogStringLine(REPORT_STANDARD, "The executable path is not in a secure location: %ls", pLaunchApprovedExe->sczExecutablePath);
+        ExitFunction1(hr = HRESULT_FROM_WIN32(ERROR_ACCESS_DENIED));
+    }
+
+    hr = ApprovedExesLaunch(pVariables, pLaunchApprovedExe, &dwProcessId);
+    ExitOnFailure(hr, "Failed to launch approved exe: %ls", pLaunchApprovedExe->sczExecutablePath);
+
+    //send process id over pipe
+    hr = BuffWriteNumber(&pbSendData, &cbSendData, dwProcessId);
+    ExitOnFailure(hr, "Failed to write the approved exe process id to message buffer.");
+
+    hr = PipeSendMessage(hPipe, BURN_ELEVATION_MESSAGE_TYPE_LAUNCH_APPROVED_EXE_PROCESSID, pbSendData, cbSendData, NULL, NULL, &dwResult);
+    ExitOnFailure(hr, "Failed to send BURN_ELEVATION_MESSAGE_TYPE_LAUNCH_APPROVED_EXE_PROCESSID message to per-user process.");
+
+LExit:
+    ReleaseBuffer(pbSendData);
+    ApprovedExesUninitializeLaunch(pLaunchApprovedExe);
+    return hr;
+}
diff --git a/src/engine/elevation.h b/src/engine/elevation.h
new file mode 100644
index 00000000..d82d9b1c
--- /dev/null
+++ b/src/engine/elevation.h
@@ -0,0 +1,178 @@
+#pragma once
+// 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.
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+// Parent (per-user process) side functions.
+HRESULT ElevationElevate(
+    __in BURN_ENGINE_STATE* pEngineState,
+    __in_opt HWND hwndParent
+    );
+HRESULT ElevationApplyInitialize(
+    __in HANDLE hPipe,
+    __in BURN_VARIABLES* pVariables,
+    __in BOOTSTRAPPER_ACTION action,
+    __in BURN_AU_PAUSE_ACTION auAction,
+    __in BOOL fTakeSystemRestorePoint
+    );
+HRESULT ElevationApplyUninitialize(
+    __in HANDLE hPipe
+    );
+HRESULT ElevationSessionBegin(
+    __in HANDLE hPipe,
+    __in_z LPCWSTR wzEngineWorkingPath,
+    __in_z LPCWSTR wzResumeCommandLine,
+    __in BOOL fDisableResume,
+    __in BURN_VARIABLES* pVariables,
+    __in DWORD dwRegistrationOperations,
+    __in BURN_DEPENDENCY_REGISTRATION_ACTION dependencyRegistrationAction,
+    __in DWORD64 qwEstimatedSize
+    );
+HRESULT ElevationSessionResume(
+    __in HANDLE hPipe,
+    __in_z LPCWSTR wzResumeCommandLine,
+    __in BOOL fDisableResume,
+    __in BURN_VARIABLES* pVariables
+    );
+HRESULT ElevationSessionEnd(
+    __in HANDLE hPipe,
+    __in BURN_RESUME_MODE resumeMode,
+    __in BOOTSTRAPPER_APPLY_RESTART restart,
+    __in BURN_DEPENDENCY_REGISTRATION_ACTION dependencyRegistrationAction
+    );
+HRESULT ElevationSaveState(
+    __in HANDLE hPipe,
+    __in_bcount(cbBuffer) BYTE* pbBuffer,
+    __in SIZE_T cbBuffer
+    );
+HRESULT ElevationLayoutBundle(
+    __in HANDLE hPipe,
+    __in_z LPCWSTR wzLayoutDirectory,
+    __in_z LPCWSTR wzUnverifiedPath
+    );
+HRESULT ElevationCacheOrLayoutContainerOrPayload(
+    __in HANDLE hPipe,
+    __in_opt BURN_CONTAINER* pContainer,
+    __in_opt BURN_PACKAGE* pPackage,
+    __in_opt BURN_PAYLOAD* pPayload,
+    __in_z_opt LPCWSTR wzLayoutDirectory,
+    __in_z LPCWSTR wzUnverifiedPath,
+    __in BOOL fMove
+    );
+HRESULT ElevationCacheCleanup(
+    __in HANDLE hPipe
+    );
+HRESULT ElevationProcessDependentRegistration(
+    __in HANDLE hPipe,
+    __in const BURN_DEPENDENT_REGISTRATION_ACTION* pAction
+    );
+HRESULT ElevationExecuteExePackage(
+    __in HANDLE hPipe,
+    __in BURN_EXECUTE_ACTION* pExecuteAction,
+    __in BURN_VARIABLES* pVariables,
+    __in BOOL fRollback,
+    __in PFN_GENERICMESSAGEHANDLER pfnGenericExecuteProgress,
+    __in LPVOID pvContext,
+    __out BOOTSTRAPPER_APPLY_RESTART* pRestart
+    );
+HRESULT ElevationExecuteMsiPackage(
+    __in HANDLE hPipe,
+    __in_opt HWND hwndParent,
+    __in BURN_EXECUTE_ACTION* pExecuteAction,
+    __in BURN_VARIABLES* pVariables,
+    __in BOOL fRollback,
+    __in PFN_MSIEXECUTEMESSAGEHANDLER pfnMessageHandler,
+    __in LPVOID pvContext,
+    __out BOOTSTRAPPER_APPLY_RESTART* pRestart
+    );
+HRESULT ElevationExecuteMspPackage(
+    __in HANDLE hPipe,
+    __in_opt HWND hwndParent,
+    __in BURN_EXECUTE_ACTION* pExecuteAction,
+    __in BURN_VARIABLES* pVariables,
+    __in BOOL fRollback,
+    __in PFN_MSIEXECUTEMESSAGEHANDLER pfnMessageHandler,
+    __in LPVOID pvContext,
+    __out BOOTSTRAPPER_APPLY_RESTART* pRestart
+    );
+HRESULT ElevationExecuteMsuPackage(
+    __in HANDLE hPipe,
+    __in BURN_EXECUTE_ACTION* pExecuteAction,
+    __in BOOL fRollback,
+    __in BOOL fStopWusaService,
+    __in PFN_GENERICMESSAGEHANDLER pfnGenericExecuteProgress,
+    __in LPVOID pvContext,
+    __out BOOTSTRAPPER_APPLY_RESTART* pRestart
+    );
+HRESULT ElevationExecutePackageProviderAction(
+    __in HANDLE hPipe,
+    __in BURN_EXECUTE_ACTION* pExecuteAction
+    );
+HRESULT ElevationExecutePackageDependencyAction(
+    __in HANDLE hPipe,
+    __in BURN_EXECUTE_ACTION* pExecuteAction
+    );
+HRESULT ElevationLoadCompatiblePackageAction(
+    __in HANDLE hPipe,
+    __in BURN_EXECUTE_ACTION* pExecuteAction
+    );
+HRESULT ElevationLaunchElevatedChild(
+    __in HANDLE hPipe,
+    __in BURN_PACKAGE* pPackage,
+    __in LPCWSTR wzPipeName,
+    __in LPCWSTR wzPipeToken,
+    __out DWORD* pdwChildPid
+    );
+HRESULT ElevationCleanPackage(
+    __in HANDLE hPipe,
+    __in BURN_PACKAGE* pPackage
+    );
+HRESULT ElevationLaunchApprovedExe(
+    __in HANDLE hPipe,
+    __in BURN_LAUNCH_APPROVED_EXE* pLaunchApprovedExe,
+    __out DWORD* pdwProcessId
+    );
+
+// Child (per-machine process) side functions.
+HRESULT ElevationChildPumpMessages(
+    __in DWORD dwLoggingTlsId,
+    __in HANDLE hPipe,
+    __in HANDLE hCachePipe,
+    __in BURN_APPROVED_EXES* pApprovedExes,
+    __in BURN_CONTAINERS* pContainers,
+    __in BURN_PACKAGES* pPackages,
+    __in BURN_PAYLOADS* pPayloads,
+    __in BURN_VARIABLES* pVariables,
+    __in BURN_REGISTRATION* pRegistration,
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __out HANDLE* phLock,
+    __out BOOL* pfDisabledAutomaticUpdates,
+    __out DWORD* pdwChildExitCode,
+    __out BOOL* pfRestart
+    );
+HRESULT ElevationChildResumeAutomaticUpdates();
+
+
+HRESULT ElevationMsiBeginTransaction(
+    __in HANDLE hPipe,
+    __in_opt HWND hwndParent,
+    __in LPVOID pvContext
+);
+HRESULT ElevationMsiCommitTransaction(
+    __in HANDLE hPipe,
+    __in_opt HWND hwndParent,
+    __in LPVOID pvContext
+);
+HRESULT ElevationMsiRollbackTransaction(
+    __in HANDLE hPipe,
+    __in_opt HWND hwndParent,
+    __in LPVOID pvContext
+);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/engine/embedded.cpp b/src/engine/embedded.cpp
new file mode 100644
index 00000000..09666980
--- /dev/null
+++ b/src/engine/embedded.cpp
@@ -0,0 +1,197 @@
+// 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.
+
+#include "precomp.h"
+
+
+// struct
+
+struct BURN_EMBEDDED_CALLBACK_CONTEXT
+{
+    PFN_GENERICMESSAGEHANDLER pfnGenericMessageHandler;
+    LPVOID pvContext;
+};
+
+// internal function declarations
+
+static HRESULT ProcessEmbeddedMessages(
+    __in BURN_PIPE_MESSAGE* pMsg,
+    __in_opt LPVOID pvContext,
+    __out DWORD* pdwResult
+    );
+static HRESULT OnEmbeddedErrorMessage(
+    __in PFN_GENERICMESSAGEHANDLER pfnMessageHandler,
+    __in LPVOID pvContext,
+    __in_bcount(cbData) BYTE* pbData,
+    __in DWORD cbData,
+    __out DWORD* pdwResult
+    );
+static HRESULT OnEmbeddedProgress(
+    __in PFN_GENERICMESSAGEHANDLER pfnMessageHandler,
+    __in LPVOID pvContext,
+    __in_bcount(cbData) BYTE* pbData,
+    __in DWORD cbData,
+    __out DWORD* pdwResult
+    );
+
+// function definitions
+
+/*******************************************************************
+ EmbeddedLaunchChildProcess - 
+
+*******************************************************************/
+extern "C" HRESULT EmbeddedRunBundle(
+    __in LPCWSTR wzExecutablePath,
+    __in LPCWSTR wzArguments,
+    __in PFN_GENERICMESSAGEHANDLER pfnGenericMessageHandler,
+    __in LPVOID pvContext,
+    __out DWORD* pdwExitCode
+    )
+{
+    HRESULT hr = S_OK;
+    DWORD dwCurrentProcessId = ::GetCurrentProcessId();
+    HANDLE hCreatedPipesEvent = NULL;
+    LPWSTR sczCommand = NULL;
+    STARTUPINFOW si = { };
+    PROCESS_INFORMATION pi = { };
+    BURN_PIPE_RESULT result = { };
+
+    BURN_PIPE_CONNECTION connection = { };
+    PipeConnectionInitialize(&connection);
+
+    BURN_EMBEDDED_CALLBACK_CONTEXT context = { };
+    context.pfnGenericMessageHandler = pfnGenericMessageHandler;
+    context.pvContext = pvContext;
+
+    hr = PipeCreateNameAndSecret(&connection.sczName, &connection.sczSecret);
+    ExitOnFailure(hr, "Failed to create embedded pipe name and client token.");
+
+    hr = PipeCreatePipes(&connection, FALSE, &hCreatedPipesEvent);
+    ExitOnFailure(hr, "Failed to create embedded pipe.");
+
+    hr = StrAllocFormattedSecure(&sczCommand, L"%ls -%ls %ls %ls %u", wzArguments, BURN_COMMANDLINE_SWITCH_EMBEDDED, connection.sczName, connection.sczSecret, dwCurrentProcessId);
+    ExitOnFailure(hr, "Failed to allocate embedded command.");
+
+    if (!::CreateProcessW(wzExecutablePath, sczCommand, NULL, NULL, TRUE, CREATE_NO_WINDOW, NULL, NULL, &si, &pi))
+    {
+        ExitWithLastError(hr, "Failed to create embedded process at path: %ls", wzExecutablePath);
+    }
+
+    connection.dwProcessId = ::GetProcessId(pi.hProcess);
+    connection.hProcess = pi.hProcess;
+    pi.hProcess = NULL;
+
+    hr = PipeWaitForChildConnect(&connection);
+    ExitOnFailure(hr, "Failed to wait for embedded process to connect to pipe.");
+
+    hr = PipePumpMessages(connection.hPipe, ProcessEmbeddedMessages, &context, &result);
+    ExitOnFailure(hr, "Failed to process messages from embedded message.");
+
+    // Get the return code from the embedded process.
+    hr = ProcWaitForCompletion(connection.hProcess, INFINITE, pdwExitCode);
+    ExitOnFailure(hr, "Failed to wait for embedded executable: %ls", wzExecutablePath);
+
+LExit:
+    ReleaseHandle(pi.hThread);
+    ReleaseHandle(pi.hProcess);
+
+    StrSecureZeroFreeString(sczCommand);
+    ReleaseHandle(hCreatedPipesEvent);
+    PipeConnectionUninitialize(&connection);
+
+    return hr;
+}
+
+
+// internal function definitions
+
+static HRESULT ProcessEmbeddedMessages(
+    __in BURN_PIPE_MESSAGE* pMsg,
+    __in_opt LPVOID pvContext,
+    __out DWORD* pdwResult
+    )
+{
+    HRESULT hr = S_OK;
+    BURN_EMBEDDED_CALLBACK_CONTEXT* pContext = static_cast<BURN_EMBEDDED_CALLBACK_CONTEXT*>(pvContext);
+    DWORD dwResult = 0;
+
+    // Process the message.
+    switch (pMsg->dwMessage)
+    {
+    case BURN_EMBEDDED_MESSAGE_TYPE_ERROR:
+        hr = OnEmbeddedErrorMessage(pContext->pfnGenericMessageHandler, pContext->pvContext, static_cast<BYTE*>(pMsg->pvData), pMsg->cbData, &dwResult);
+        ExitOnFailure(hr, "Failed to process embedded error message.");
+        break;
+
+    case BURN_EMBEDDED_MESSAGE_TYPE_PROGRESS:
+        hr = OnEmbeddedProgress(pContext->pfnGenericMessageHandler, pContext->pvContext, static_cast<BYTE*>(pMsg->pvData), pMsg->cbData, &dwResult);
+        ExitOnFailure(hr, "Failed to process embedded progress message.");
+        break;
+
+    default:
+        hr = E_INVALIDARG;
+        ExitOnRootFailure(hr, "Unexpected embedded message sent to child process, msg: %u", pMsg->dwMessage);
+    }
+
+    *pdwResult = dwResult;
+
+LExit:
+    return hr;
+}
+
+static HRESULT OnEmbeddedErrorMessage(
+    __in PFN_GENERICMESSAGEHANDLER pfnMessageHandler,
+    __in LPVOID pvContext,
+    __in_bcount(cbData) BYTE* pbData,
+    __in DWORD cbData,
+    __out DWORD* pdwResult
+    )
+{
+    HRESULT hr = S_OK;
+    DWORD iData = 0;
+    GENERIC_EXECUTE_MESSAGE message = { };
+    LPWSTR sczMessage = NULL;
+
+    message.type = GENERIC_EXECUTE_MESSAGE_ERROR;
+
+    hr = BuffReadNumber(pbData, cbData, &iData, &message.error.dwErrorCode);
+    ExitOnFailure(hr, "Failed to read error code from buffer.");
+
+    hr = BuffReadString(pbData, cbData, &iData, &sczMessage);
+    ExitOnFailure(hr, "Failed to read error message from buffer.");
+
+    message.error.wzMessage = sczMessage;
+
+    hr = BuffReadNumber(pbData, cbData, &iData, &message.dwAllowedResults);
+    ExitOnFailure(hr, "Failed to read UI hint from buffer.");
+
+    *pdwResult = (DWORD)pfnMessageHandler(&message, pvContext);
+
+LExit:
+    ReleaseStr(sczMessage);
+
+    return hr;
+}
+
+static HRESULT OnEmbeddedProgress(
+    __in PFN_GENERICMESSAGEHANDLER pfnMessageHandler,
+    __in LPVOID pvContext,
+    __in_bcount(cbData) BYTE* pbData,
+    __in DWORD cbData,
+    __out DWORD* pdwResult
+    )
+{
+    HRESULT hr = S_OK;
+    DWORD iData = 0;
+    GENERIC_EXECUTE_MESSAGE message = { };
+
+    message.type = GENERIC_EXECUTE_MESSAGE_PROGRESS;
+    message.dwAllowedResults = MB_OKCANCEL;
+
+    hr = BuffReadNumber(pbData, cbData, &iData, &message.progress.dwPercentage);
+    ExitOnFailure(hr, "Failed to read progress from buffer.");
+
+    *pdwResult = (DWORD)pfnMessageHandler(&message, pvContext);
+
+LExit:
+    return hr;
+}
diff --git a/src/engine/embedded.h b/src/engine/embedded.h
new file mode 100644
index 00000000..08adeae0
--- /dev/null
+++ b/src/engine/embedded.h
@@ -0,0 +1,27 @@
+#pragma once
+// 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.
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum _BURN_EMBEDDED_MESSAGE_TYPE
+{
+    BURN_EMBEDDED_MESSAGE_TYPE_UNKNOWN,
+    BURN_EMBEDDED_MESSAGE_TYPE_ERROR,
+    BURN_EMBEDDED_MESSAGE_TYPE_PROGRESS,
+} BURN_EMBEDDED_MESSAGE_TYPE;
+
+
+HRESULT EmbeddedRunBundle(
+    __in LPCWSTR wzExecutablePath,
+    __in LPCWSTR wzArguments,
+    __in PFN_GENERICMESSAGEHANDLER pfnGenericMessageHandler,
+    __in LPVOID pvContext,
+    __out DWORD* pdwExitCode
+    );
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/engine/engine.cpp b/src/engine/engine.cpp
new file mode 100644
index 00000000..3c0f09c9
--- /dev/null
+++ b/src/engine/engine.cpp
@@ -0,0 +1,889 @@
+// 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.
+
+#include "precomp.h"
+
+
+// constants
+
+const DWORD RESTART_RETRIES = 10;
+
+// internal function declarations
+
+static HRESULT InitializeEngineState(
+    __in BURN_ENGINE_STATE* pEngineState,
+    __in HANDLE hEngineFile
+    );
+static void UninitializeEngineState(
+    __in BURN_ENGINE_STATE* pEngineState
+    );
+static HRESULT RunUntrusted(
+    __in LPCWSTR wzCommandLine,
+    __in BURN_ENGINE_STATE* pEngineState
+    );
+static HRESULT RunNormal(
+    __in HINSTANCE hInstance,
+    __in BURN_ENGINE_STATE* pEngineState
+    );
+static HRESULT RunElevated(
+    __in HINSTANCE hInstance,
+    __in LPCWSTR wzCommandLine,
+    __in BURN_ENGINE_STATE* pEngineState
+    );
+static HRESULT RunEmbedded(
+    __in HINSTANCE hInstance,
+    __in BURN_ENGINE_STATE* pEngineState
+    );
+static HRESULT RunRunOnce(
+    __in const BURN_REGISTRATION* pRegistration,
+    __in int nCmdShow
+    );
+static HRESULT RunApplication(
+    __in BURN_ENGINE_STATE* pEngineState,
+    __out BOOL* pfReloadApp
+    );
+static HRESULT ProcessMessage(
+    __in BURN_ENGINE_STATE* pEngineState,
+    __in const MSG* pmsg
+    );
+static HRESULT DAPI RedirectLoggingOverPipe(
+    __in_z LPCSTR szString,
+    __in_opt LPVOID pvContext
+    );
+static HRESULT Restart();
+
+
+// function definitions
+
+extern "C" BOOL EngineInCleanRoom(
+    __in_z_opt LPCWSTR wzCommandLine
+    )
+{
+    // Be very careful with the functions you call from here.
+    // This function will be called before ::SetDefaultDllDirectories()
+    // has been called so dependencies outside of kernel32.dll are
+    // very likely to introduce DLL hijacking opportunities.
+
+    static DWORD cchCleanRoomSwitch = lstrlenW(BURN_COMMANDLINE_SWITCH_CLEAN_ROOM);
+
+    // This check is wholly dependent on the clean room command line switch being
+    // present at the beginning of the command line. Since Burn is the only thing
+    // that should be setting this command line option, that is in our control.
+    BOOL fInCleanRoom = (wzCommandLine &&
+        (wzCommandLine[0] == L'-' || wzCommandLine[0] == L'/') &&
+        CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, NORM_IGNORECASE, wzCommandLine + 1, cchCleanRoomSwitch, BURN_COMMANDLINE_SWITCH_CLEAN_ROOM, cchCleanRoomSwitch) &&
+        wzCommandLine[1 + cchCleanRoomSwitch] == L'='
+    );
+
+    return fInCleanRoom;
+}
+
+extern "C" HRESULT EngineRun(
+    __in HINSTANCE hInstance,
+    __in HANDLE hEngineFile,
+    __in_z_opt LPCWSTR wzCommandLine,
+    __in int nCmdShow,
+    __out DWORD* pdwExitCode
+    )
+{
+    HRESULT hr = S_OK;
+    BOOL fComInitialized = FALSE;
+    BOOL fLogInitialized = FALSE;
+    BOOL fCrypInitialized = FALSE;
+    BOOL fRegInitialized = FALSE;
+    BOOL fWiuInitialized = FALSE;
+    BOOL fXmlInitialized = FALSE;
+    OSVERSIONINFOEXW ovix = { };
+    LPWSTR sczExePath = NULL;
+    BOOL fRunNormal = FALSE;
+    BOOL fRestart = FALSE;
+
+    BURN_ENGINE_STATE engineState = { };
+
+    // Always initialize logging first
+    LogInitialize(::GetModuleHandleW(NULL));
+    fLogInitialized = TRUE;
+
+    // Ensure that log contains approriate level of information
+#ifdef _DEBUG
+    LogSetLevel(REPORT_DEBUG, FALSE);
+#else
+    LogSetLevel(REPORT_VERBOSE, FALSE); // FALSE means don't write an additional text line to the log saying the level changed
+#endif
+
+    hr = AppParseCommandLine(wzCommandLine, &engineState.argc, &engineState.argv);
+    ExitOnFailure(hr, "Failed to parse command line.");
+
+    hr = InitializeEngineState(&engineState, hEngineFile);
+    ExitOnFailure(hr, "Failed to initialize engine state.");
+
+    engineState.command.nCmdShow = nCmdShow;
+
+    // initialize platform layer
+    PlatformInitialize();
+
+    // initialize COM
+    hr = ::CoInitializeEx(NULL, COINIT_MULTITHREADED);
+    ExitOnFailure(hr, "Failed to initialize COM.");
+    fComInitialized = TRUE;
+
+    // Initialize dutil.
+    hr = CrypInitialize();
+    ExitOnFailure(hr, "Failed to initialize Cryputil.");
+    fCrypInitialized = TRUE;
+
+    hr = RegInitialize();
+    ExitOnFailure(hr, "Failed to initialize Regutil.");
+    fRegInitialized = TRUE;
+
+    hr = WiuInitialize();
+    ExitOnFailure(hr, "Failed to initialize Wiutil.");
+    fWiuInitialized = TRUE;
+
+    hr = XmlInitialize();
+    ExitOnFailure(hr, "Failed to initialize XML util.");
+    fXmlInitialized = TRUE;
+
+    ovix.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXW);
+    if (!::GetVersionExW((LPOSVERSIONINFOW)&ovix))
+    {
+        ExitWithLastError(hr, "Failed to get OS info.");
+    }
+
+    PathForCurrentProcess(&sczExePath, NULL); // Ignore failure.
+    LogId(REPORT_STANDARD, MSG_BURN_INFO, szVerMajorMinorBuild, ovix.dwMajorVersion, ovix.dwMinorVersion, ovix.dwBuildNumber, ovix.wServicePackMajor, sczExePath);
+    ReleaseNullStr(sczExePath);
+
+    // initialize core
+    hr = CoreInitialize(&engineState);
+    ExitOnFailure(hr, "Failed to initialize core.");
+
+    // Select run mode.
+    switch (engineState.mode)
+    {
+    case BURN_MODE_UNTRUSTED:
+        hr = RunUntrusted(wzCommandLine, &engineState);
+        ExitOnFailure(hr, "Failed to run untrusted mode.");
+        break;
+
+    case BURN_MODE_NORMAL:
+        fRunNormal = TRUE;
+
+        hr = RunNormal(hInstance, &engineState);
+        ExitOnFailure(hr, "Failed to run per-user mode.");
+        break;
+
+    case BURN_MODE_ELEVATED:
+        hr = RunElevated(hInstance, wzCommandLine, &engineState);
+        ExitOnFailure(hr, "Failed to run per-machine mode.");
+        break;
+
+    case BURN_MODE_EMBEDDED:
+        fRunNormal = TRUE;
+
+        hr = RunEmbedded(hInstance, &engineState);
+        ExitOnFailure(hr, "Failed to run embedded mode.");
+        break;
+
+    case BURN_MODE_RUNONCE:
+        hr = RunRunOnce(&engineState.registration, nCmdShow);
+        ExitOnFailure(hr, "Failed to run RunOnce mode.");
+        break;
+
+    default:
+        hr = E_UNEXPECTED;
+        ExitOnFailure(hr, "Invalid run mode.");
+    }
+
+    // set exit code and remember if we are supposed to restart.
+    *pdwExitCode = engineState.userExperience.dwExitCode;
+    fRestart = engineState.fRestart;
+
+LExit:
+    ReleaseStr(sczExePath);
+
+    // If anything went wrong but the log was never open, try to open a "failure" log
+    // and that will dump anything captured in the log memory buffer to the log.
+    if (FAILED(hr) && BURN_LOGGING_STATE_CLOSED == engineState.log.state)
+    {
+        LoggingOpenFailed();
+    }
+
+    UserExperienceRemove(&engineState.userExperience);
+
+    CacheRemoveWorkingFolder(engineState.registration.sczId);
+    CacheUninitialize();
+
+    // If this is a related bundle (but not an update) suppress restart and return the standard restart error code.
+    if (fRestart && BOOTSTRAPPER_RELATION_NONE != engineState.command.relationType && BOOTSTRAPPER_RELATION_UPDATE != engineState.command.relationType)
+    {
+        LogId(REPORT_STANDARD, MSG_RESTART_ABORTED, LoggingRelationTypeToString(engineState.command.relationType));
+
+        fRestart = FALSE;
+        hr = HRESULT_FROM_WIN32(ERROR_SUCCESS_REBOOT_REQUIRED);
+    }
+
+    UninitializeEngineState(&engineState);
+
+    if (fXmlInitialized)
+    {
+        XmlUninitialize();
+    }
+
+    if (fWiuInitialized)
+    {
+        WiuUninitialize();
+    }
+
+    if (fRegInitialized)
+    {
+        RegUninitialize();
+    }
+
+    if (fCrypInitialized)
+    {
+        CrypUninitialize();
+    }
+
+    if (fComInitialized)
+    {
+        ::CoUninitialize();
+    }
+
+    if (fRunNormal)
+    {
+        LogId(REPORT_STANDARD, MSG_EXITING, FAILED(hr) ? (int)hr : *pdwExitCode, LoggingBoolToString(fRestart));
+
+        if (fRestart)
+        {
+            LogId(REPORT_STANDARD, MSG_RESTARTING);
+        }
+    }
+
+    if (fLogInitialized)
+    {
+        LogClose(FALSE);
+    }
+
+    if (fRestart)
+    {
+        Restart();
+    }
+
+    if (fLogInitialized)
+    {
+        LogUninitialize(FALSE);
+    }
+
+    return hr;
+}
+
+
+// internal function definitions
+
+static HRESULT InitializeEngineState(
+    __in BURN_ENGINE_STATE* pEngineState,
+    __in HANDLE hEngineFile
+    )
+{
+    HRESULT hr = S_OK;
+    LPCWSTR wzParam = NULL;
+    HANDLE hSectionFile = hEngineFile;
+    HANDLE hSourceEngineFile = INVALID_HANDLE_VALUE;
+
+    pEngineState->automaticUpdates = BURN_AU_PAUSE_ACTION_IFELEVATED;
+    pEngineState->dwElevatedLoggingTlsId = TLS_OUT_OF_INDEXES;
+    ::InitializeCriticalSection(&pEngineState->csActive);
+    ::InitializeCriticalSection(&pEngineState->userExperience.csEngineActive);
+    PipeConnectionInitialize(&pEngineState->companionConnection);
+    PipeConnectionInitialize(&pEngineState->embeddedConnection);
+
+    for (int i = 0; i < pEngineState->argc; ++i)
+    {
+        if (pEngineState->argv[i][0] == L'-')
+        {
+            if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, NORM_IGNORECASE, &pEngineState->argv[i][1], lstrlenW(BURN_COMMANDLINE_SWITCH_FILEHANDLE_ATTACHED), BURN_COMMANDLINE_SWITCH_FILEHANDLE_ATTACHED, lstrlenW(BURN_COMMANDLINE_SWITCH_FILEHANDLE_ATTACHED)))
+            {
+                wzParam = &pEngineState->argv[i][2 + lstrlenW(BURN_COMMANDLINE_SWITCH_FILEHANDLE_ATTACHED)];
+                if (L'=' != wzParam[-1] || L'\0' == wzParam[0])
+                {
+                    ExitOnRootFailure(hr = E_INVALIDARG, "Missing required parameter for switch: %ls", BURN_COMMANDLINE_SWITCH_FILEHANDLE_ATTACHED);
+                }
+
+                hr = StrStringToUInt32(wzParam, 0, reinterpret_cast<UINT*>(&hSourceEngineFile));
+                ExitOnFailure(hr, "Failed to parse file handle: '%ls'", (wzParam));
+            }
+            if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, NORM_IGNORECASE, &pEngineState->argv[i][1], lstrlenW(BURN_COMMANDLINE_SWITCH_FILEHANDLE_SELF), BURN_COMMANDLINE_SWITCH_FILEHANDLE_SELF, lstrlenW(BURN_COMMANDLINE_SWITCH_FILEHANDLE_SELF)))
+            {
+                wzParam = &pEngineState->argv[i][2 + lstrlenW(BURN_COMMANDLINE_SWITCH_FILEHANDLE_SELF)];
+                if (L'=' != wzParam[-1] || L'\0' == wzParam[0])
+                {
+                    ExitOnRootFailure(hr = E_INVALIDARG, "Missing required parameter for switch: %ls", BURN_COMMANDLINE_SWITCH_FILEHANDLE_SELF);
+                }
+
+                hr = StrStringToUInt32(wzParam, 0, reinterpret_cast<UINT*>(&hSectionFile));
+                ExitOnFailure(hr, "Failed to parse file handle: '%ls'", (wzParam));
+            }
+        }
+    }
+
+    hr = SectionInitialize(&pEngineState->section, hSectionFile, hSourceEngineFile);
+    ExitOnFailure(hr, "Failed to initialize engine section.");
+
+LExit:
+    return hr;
+}
+
+static void UninitializeEngineState(
+    __in BURN_ENGINE_STATE* pEngineState
+    )
+{
+    if (pEngineState->argv)
+    {
+        AppFreeCommandLineArgs(pEngineState->argv);
+    }
+
+    ReleaseStr(pEngineState->sczIgnoreDependencies);
+
+    PipeConnectionUninitialize(&pEngineState->embeddedConnection);
+    PipeConnectionUninitialize(&pEngineState->companionConnection);
+    ReleaseStr(pEngineState->sczBundleEngineWorkingPath)
+
+    ReleaseHandle(pEngineState->hMessageWindowThread);
+
+    ::DeleteCriticalSection(&pEngineState->userExperience.csEngineActive);
+    UserExperienceUninitialize(&pEngineState->userExperience);
+
+    ApprovedExesUninitialize(&pEngineState->approvedExes);
+    UpdateUninitialize(&pEngineState->update);
+    VariablesUninitialize(&pEngineState->variables);
+    SearchesUninitialize(&pEngineState->searches);
+    RegistrationUninitialize(&pEngineState->registration);
+    PayloadsUninitialize(&pEngineState->payloads);
+    PackagesUninitialize(&pEngineState->packages);
+    CatalogUninitialize(&pEngineState->catalogs);
+    SectionUninitialize(&pEngineState->section);
+    ContainersUninitialize(&pEngineState->containers);
+
+    ReleaseStr(pEngineState->command.wzLayoutDirectory);
+    ReleaseStr(pEngineState->command.wzCommandLine);
+
+    ReleaseStr(pEngineState->log.sczExtension);
+    ReleaseStr(pEngineState->log.sczPrefix);
+    ReleaseStr(pEngineState->log.sczPath);
+    ReleaseStr(pEngineState->log.sczPathVariable);
+
+    if (TLS_OUT_OF_INDEXES != pEngineState->dwElevatedLoggingTlsId)
+    {
+        ::TlsFree(pEngineState->dwElevatedLoggingTlsId);
+    }
+
+    ::DeleteCriticalSection(&pEngineState->csActive);
+
+    // clear struct
+    memset(pEngineState, 0, sizeof(BURN_ENGINE_STATE));
+}
+
+static HRESULT RunUntrusted(
+    __in LPCWSTR wzCommandLine,
+    __in BURN_ENGINE_STATE* pEngineState
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR sczCurrentProcessPath = NULL;
+    LPWSTR wzCleanRoomBundlePath = NULL;
+    LPWSTR sczCachedCleanRoomBundlePath = NULL;
+    LPWSTR sczParameters = NULL;
+    LPWSTR sczFullCommandLine = NULL;
+    STARTUPINFOW si = { };
+    PROCESS_INFORMATION pi = { };
+    HANDLE hFileAttached = NULL;
+    HANDLE hFileSelf = NULL;
+    HANDLE hProcess = NULL;
+
+    hr = PathForCurrentProcess(&sczCurrentProcessPath, NULL);
+    ExitOnFailure(hr, "Failed to get path for current process.");
+
+    BOOL fRunningFromCache = CacheBundleRunningFromCache();
+
+    // If we're running from the package cache, we're in a secure
+    // folder (DLLs cannot be inserted here for hijacking purposes)
+    // so just launch the current process's path as the clean room
+    // process. Technically speaking, we'd be able to skip creating
+    // a clean room process at all (since we're already running from
+    // a secure folder) but it makes the code that only wants to run
+    // in clean room more complicated if we don't launch an explicit
+    // clean room process.
+    if (fRunningFromCache)
+    {
+        wzCleanRoomBundlePath = sczCurrentProcessPath;
+    }
+    else
+    {
+        hr = CacheBundleToCleanRoom(&pEngineState->userExperience.payloads, &pEngineState->section, &sczCachedCleanRoomBundlePath);
+        ExitOnFailure(hr, "Failed to cache to clean room.");
+
+        wzCleanRoomBundlePath = sczCachedCleanRoomBundlePath;
+    }
+
+    // The clean room switch must always be at the front of the command line so
+    // the EngineInCleanRoom function will operate correctly.
+    hr = StrAllocFormatted(&sczParameters, L"-%ls=\"%ls\"", BURN_COMMANDLINE_SWITCH_CLEAN_ROOM, sczCurrentProcessPath);
+    ExitOnFailure(hr, "Failed to allocate parameters for unelevated process.");
+
+    // Send a file handle for the child Burn process to access the attached container.
+    hr = CoreAppendFileHandleAttachedToCommandLine(pEngineState->section.hEngineFile, &hFileAttached, &sczParameters);
+    ExitOnFailure(hr, "Failed to append %ls", BURN_COMMANDLINE_SWITCH_FILEHANDLE_ATTACHED);
+
+    // Grab a file handle for the child Burn process.
+    hr = CoreAppendFileHandleSelfToCommandLine(wzCleanRoomBundlePath, &hFileSelf, &sczParameters, NULL);
+    ExitOnFailure(hr, "Failed to append %ls", BURN_COMMANDLINE_SWITCH_FILEHANDLE_SELF);
+
+    hr = StrAllocFormattedSecure(&sczParameters, L"%ls %ls", sczParameters, wzCommandLine);
+    ExitOnFailure(hr, "Failed to append original command line.");
+
+#ifdef ENABLE_UNELEVATE
+    // TODO: Pass file handle to unelevated process if this ever gets reenabled.
+    if (!pEngineState->fDisableUnelevate)
+    {
+        // Try to launch unelevated and if that fails for any reason, we'll launch our process normally (even though that may make it elevated).
+        hr = ProcExecuteAsInteractiveUser(wzCleanRoomBundlePath, sczParameters, &hProcess);
+    }
+#endif
+
+    if (!hProcess)
+    {
+        hr = StrAllocFormattedSecure(&sczFullCommandLine, L"\"%ls\" %ls", wzCleanRoomBundlePath, sczParameters);
+        ExitOnFailure(hr, "Failed to allocate full command-line.");
+
+        si.cb = sizeof(si);
+        si.wShowWindow = static_cast<WORD>(pEngineState->command.nCmdShow);
+        if (!::CreateProcessW(wzCleanRoomBundlePath, sczFullCommandLine, NULL, NULL, TRUE, 0, 0, NULL, &si, &pi))
+        {
+            ExitWithLastError(hr, "Failed to launch clean room process: %ls", sczFullCommandLine);
+        }
+
+        hProcess = pi.hProcess;
+        pi.hProcess = NULL;
+    }
+
+    hr = ProcWaitForCompletion(hProcess, INFINITE, &pEngineState->userExperience.dwExitCode);
+    ExitOnFailure(hr, "Failed to wait for clean room process: %ls", wzCleanRoomBundlePath);
+
+LExit:
+    ReleaseHandle(pi.hThread);
+    ReleaseFileHandle(hFileSelf);
+    ReleaseFileHandle(hFileAttached);
+    ReleaseHandle(hProcess);
+    StrSecureZeroFreeString(sczFullCommandLine);
+    StrSecureZeroFreeString(sczParameters);
+    ReleaseStr(sczCachedCleanRoomBundlePath);
+    ReleaseStr(sczCurrentProcessPath);
+
+    return hr;
+}
+
+static HRESULT RunNormal(
+    __in HINSTANCE hInstance,
+    __in BURN_ENGINE_STATE* pEngineState
+    )
+{
+    HRESULT hr = S_OK;
+    HANDLE hPipesCreatedEvent = NULL;
+    BOOL fContinueExecution = TRUE;
+    BOOL fReloadApp = FALSE;
+
+    // Initialize logging.
+    hr = LoggingOpen(&pEngineState->log, &pEngineState->variables, pEngineState->command.display, pEngineState->registration.sczDisplayName);
+    ExitOnFailure(hr, "Failed to open log.");
+
+    // Ensure we're on a supported operating system.
+    hr = ConditionGlobalCheck(&pEngineState->variables, &pEngineState->condition, pEngineState->command.display, pEngineState->registration.sczDisplayName, &pEngineState->userExperience.dwExitCode, &fContinueExecution);
+    ExitOnFailure(hr, "Failed to check global conditions");
+
+    if (!fContinueExecution)
+    {
+        LogId(REPORT_STANDARD, MSG_FAILED_CONDITION_CHECK);
+
+        // If the block told us to abort, abort!
+        ExitFunction1(hr = S_OK);
+    }
+
+    if (pEngineState->userExperience.fSplashScreen && BOOTSTRAPPER_DISPLAY_NONE < pEngineState->command.display)
+    {
+        SplashScreenCreate(hInstance, NULL, &pEngineState->command.hwndSplashScreen);
+    }
+
+    // Create a top-level window to handle system messages.
+    hr = UiCreateMessageWindow(hInstance, pEngineState);
+    ExitOnFailure(hr, "Failed to create the message window.");
+
+    // Query registration state.
+    hr = CoreQueryRegistration(pEngineState);
+    ExitOnFailure(hr, "Failed to query registration.");
+
+    // Set some built-in variables before loading the BA.
+    hr = PlanSetVariables(pEngineState->command.action, &pEngineState->variables);
+    ExitOnFailure(hr, "Failed to set action variables.");
+
+    hr = RegistrationSetVariables(&pEngineState->registration, &pEngineState->variables);
+    ExitOnFailure(hr, "Failed to set registration variables.");
+
+    // If a layout directory was specified on the command-line, set it as a well-known variable.
+    if (pEngineState->command.wzLayoutDirectory && *pEngineState->command.wzLayoutDirectory)
+    {
+        hr = VariableSetString(&pEngineState->variables, BURN_BUNDLE_LAYOUT_DIRECTORY, pEngineState->command.wzLayoutDirectory, FALSE);
+        ExitOnFailure(hr, "Failed to set layout directory variable to value provided from command-line.");
+    }
+
+    do
+    {
+        fReloadApp = FALSE;
+
+        hr = RunApplication(pEngineState, &fReloadApp);
+        ExitOnFailure(hr, "Failed while running ");
+    } while (fReloadApp);
+
+LExit:
+    // If the message window is still around, close it.
+    UiCloseMessageWindow(pEngineState);
+
+    VariablesDump(&pEngineState->variables);
+
+    // end per-machine process if running
+    if (INVALID_HANDLE_VALUE != pEngineState->companionConnection.hPipe)
+    {
+        PipeTerminateChildProcess(&pEngineState->companionConnection, pEngineState->userExperience.dwExitCode, FALSE);
+    }
+
+    // If the splash screen is still around, close it.
+    if (::IsWindow(pEngineState->command.hwndSplashScreen))
+    {
+        ::PostMessageW(pEngineState->command.hwndSplashScreen, WM_CLOSE, 0, 0);
+    }
+
+    ReleaseHandle(hPipesCreatedEvent);
+
+    return hr;
+}
+
+static HRESULT RunElevated(
+    __in HINSTANCE hInstance,
+    __in LPCWSTR /*wzCommandLine*/,
+    __in BURN_ENGINE_STATE* pEngineState
+    )
+{
+    HRESULT hr = S_OK;
+    HANDLE hLock = NULL;
+    BOOL fDisabledAutomaticUpdates = FALSE;
+
+    // connect to per-user process
+    hr = PipeChildConnect(&pEngineState->companionConnection, TRUE);
+    ExitOnFailure(hr, "Failed to connect to unelevated process.");
+
+    // Set up the thread local storage to store the correct pipe to communicate logging then
+    // override logging to write over the pipe.
+    pEngineState->dwElevatedLoggingTlsId = ::TlsAlloc();
+    if (TLS_OUT_OF_INDEXES == pEngineState->dwElevatedLoggingTlsId)
+    {
+        ExitWithLastError(hr, "Failed to allocate thread local storage for logging.");
+    }
+
+    if (!::TlsSetValue(pEngineState->dwElevatedLoggingTlsId, pEngineState->companionConnection.hPipe))
+    {
+        ExitWithLastError(hr, "Failed to set elevated pipe into thread local storage for logging.");
+    }
+
+    LogRedirect(RedirectLoggingOverPipe, pEngineState);
+
+    // Create a top-level window to prevent shutting down the elevated process.
+    hr = UiCreateMessageWindow(hInstance, pEngineState);
+    ExitOnFailure(hr, "Failed to create the message window.");
+
+    SrpInitialize(TRUE);
+
+    // Pump messages from parent process.
+    hr = ElevationChildPumpMessages(pEngineState->dwElevatedLoggingTlsId, pEngineState->companionConnection.hPipe, pEngineState->companionConnection.hCachePipe, &pEngineState->approvedExes, &pEngineState->containers, &pEngineState->packages, &pEngineState->payloads, &pEngineState->variables, &pEngineState->registration, &pEngineState->userExperience, &hLock, &fDisabledAutomaticUpdates, &pEngineState->userExperience.dwExitCode, &pEngineState->fRestart);
+    LogRedirect(NULL, NULL); // reset logging so the next failure gets written to "log buffer" for the failure log.
+    ExitOnFailure(hr, "Failed to pump messages from parent process.");
+
+LExit:
+    LogRedirect(NULL, NULL); // we're done talking to the child so always reset logging now.
+
+    // If the message window is still around, close it.
+    UiCloseMessageWindow(pEngineState);
+
+    if (fDisabledAutomaticUpdates)
+    {
+        ElevationChildResumeAutomaticUpdates();
+    }
+
+    if (hLock)
+    {
+        ::ReleaseMutex(hLock);
+        ::CloseHandle(hLock);
+    }
+
+    return hr;
+}
+
+static HRESULT RunEmbedded(
+    __in HINSTANCE hInstance,
+    __in BURN_ENGINE_STATE* pEngineState
+    )
+{
+    HRESULT hr = S_OK;
+
+    // Disable system restore since the parent bundle may have done it.
+    pEngineState->fDisableSystemRestore = TRUE;
+
+    // Connect to parent process.
+    hr = PipeChildConnect(&pEngineState->embeddedConnection, FALSE);
+    ExitOnFailure(hr, "Failed to connect to parent of embedded process.");
+
+    // Do not register the bundle to automatically restart if embedded.
+    if (BOOTSTRAPPER_DISPLAY_EMBEDDED == pEngineState->command.display)
+    {
+        pEngineState->registration.fDisableResume = TRUE;
+    }
+
+    // Now run the application like normal.
+    hr = RunNormal(hInstance, pEngineState);
+    ExitOnFailure(hr, "Failed to run bootstrapper application embedded.");
+
+LExit:
+    return hr;
+}
+
+static HRESULT RunRunOnce(
+    __in const BURN_REGISTRATION* pRegistration,
+    __in int nCmdShow
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR sczNewCommandLine = NULL;
+    LPWSTR sczBurnPath = NULL;
+    HANDLE hProcess = NULL;
+
+    hr = RegistrationGetResumeCommandLine(pRegistration, &sczNewCommandLine);
+    ExitOnFailure(hr, "Unable to get resume command line from the registry");
+
+    // and re-launch
+    hr = PathForCurrentProcess(&sczBurnPath, NULL);
+    ExitOnFailure(hr, "Failed to get current process path.");
+
+    hr = ProcExec(sczBurnPath, 0 < sczNewCommandLine ? sczNewCommandLine : L"", nCmdShow, &hProcess);
+    ExitOnFailure(hr, "Failed to re-launch bundle process after RunOnce: %ls", sczBurnPath);
+
+LExit:
+    ReleaseHandle(hProcess);
+    ReleaseStr(sczNewCommandLine);
+    ReleaseStr(sczBurnPath);
+
+    return hr;
+}
+
+static HRESULT RunApplication(
+    __in BURN_ENGINE_STATE* pEngineState,
+    __out BOOL* pfReloadApp
+    )
+{
+    HRESULT hr = S_OK;
+    BOOTSTRAPPER_ENGINE_CONTEXT engineContext = { };
+    BOOL fStartupCalled = FALSE;
+    BOOL fRet = FALSE;
+    MSG msg = { };
+    BOOTSTRAPPER_SHUTDOWN_ACTION shutdownAction = BOOTSTRAPPER_SHUTDOWN_ACTION_NONE;
+
+    ::PeekMessageW(&msg, NULL, WM_USER, WM_USER, PM_NOREMOVE);
+
+    // Setup the bootstrapper engine.
+    engineContext.dwThreadId = ::GetCurrentThreadId();
+    engineContext.pEngineState = pEngineState;
+
+    // Load the bootstrapper application.
+    hr = UserExperienceLoad(&pEngineState->userExperience, &engineContext, &pEngineState->command);
+    ExitOnFailure(hr, "Failed to load BA.");
+
+    fStartupCalled = TRUE;
+    hr = UserExperienceOnStartup(&pEngineState->userExperience);
+    ExitOnFailure(hr, "Failed to start bootstrapper application.");
+
+    // Enter the message pump.
+    while (0 != (fRet = ::GetMessageW(&msg, NULL, 0, 0)))
+    {
+        if (-1 == fRet)
+        {
+            hr = E_UNEXPECTED;
+            ExitOnRootFailure(hr, "Unexpected return value from message pump.");
+        }
+        else
+        {
+            ProcessMessage(pEngineState, &msg);
+        }
+    }
+
+    // Get exit code.
+    pEngineState->userExperience.dwExitCode = (DWORD)msg.wParam;
+
+LExit:
+    if (fStartupCalled)
+    {
+        UserExperienceOnShutdown(&pEngineState->userExperience, &shutdownAction);
+        if (BOOTSTRAPPER_SHUTDOWN_ACTION_RESTART == shutdownAction)
+        {
+            LogId(REPORT_STANDARD, MSG_BA_REQUESTED_RESTART, LoggingBoolToString(pEngineState->fRestart));
+            pEngineState->fRestart = TRUE;
+        }
+        else if (BOOTSTRAPPER_SHUTDOWN_ACTION_RELOAD_BOOTSTRAPPER == shutdownAction)
+        {
+            LogId(REPORT_STANDARD, MSG_BA_REQUESTED_RELOAD);
+            *pfReloadApp = TRUE;
+        }
+    }
+
+    // Unload BA.
+    UserExperienceUnload(&pEngineState->userExperience);
+
+    return hr;
+}
+
+static HRESULT ProcessMessage(
+    __in BURN_ENGINE_STATE* pEngineState,
+    __in const MSG* pmsg
+    )
+{
+    HRESULT hr = S_OK;
+
+    switch (pmsg->message)
+    {
+    case WM_BURN_DETECT:
+        hr = CoreDetect(pEngineState, reinterpret_cast<HWND>(pmsg->lParam));
+        break;
+
+    case WM_BURN_PLAN:
+        hr = CorePlan(pEngineState, static_cast<BOOTSTRAPPER_ACTION>(pmsg->lParam));
+        break;
+
+    case WM_BURN_ELEVATE:
+        hr = CoreElevate(pEngineState, reinterpret_cast<HWND>(pmsg->lParam));
+        break;
+
+    case WM_BURN_APPLY:
+        hr = CoreApply(pEngineState, reinterpret_cast<HWND>(pmsg->lParam));
+        break;
+
+    case WM_BURN_LAUNCH_APPROVED_EXE:
+        hr = CoreLaunchApprovedExe(pEngineState, reinterpret_cast<BURN_LAUNCH_APPROVED_EXE*>(pmsg->lParam));
+        break;
+
+    case WM_BURN_QUIT:
+        hr = CoreQuit(pEngineState, static_cast<int>(pmsg->wParam));
+        break;
+    }
+
+    return hr;
+}
+
+static HRESULT DAPI RedirectLoggingOverPipe(
+    __in_z LPCSTR szString,
+    __in_opt LPVOID pvContext
+    )
+{
+    static BOOL s_fCurrentlyLoggingToPipe = FALSE;
+
+    HRESULT hr = S_OK;
+    BURN_ENGINE_STATE* pEngineState = static_cast<BURN_ENGINE_STATE*>(pvContext);
+    BOOL fStartedLogging = FALSE;
+    HANDLE hPipe = INVALID_HANDLE_VALUE;
+    BYTE* pbData = NULL;
+    SIZE_T cbData = 0;
+    DWORD dwResult = 0;
+
+    // Prevent this function from being called recursively.
+    if (s_fCurrentlyLoggingToPipe)
+    {
+        ExitFunction();
+    }
+
+    s_fCurrentlyLoggingToPipe = TRUE;
+    fStartedLogging = TRUE;
+
+    // Make sure the current thread set the pipe in TLS.
+    hPipe = ::TlsGetValue(pEngineState->dwElevatedLoggingTlsId);
+    if (!hPipe || INVALID_HANDLE_VALUE == hPipe)
+    {
+        hr = HRESULT_FROM_WIN32(ERROR_PIPE_NOT_CONNECTED);
+        ExitFunction();
+    }
+
+    // Do not log or use ExitOnFailure() macro here because they will be discarded
+    // by the recursive block at the top of this function.
+    hr = BuffWriteStringAnsi(&pbData, &cbData, szString);
+    if (SUCCEEDED(hr))
+    {
+        hr = PipeSendMessage(hPipe, static_cast<DWORD>(BURN_PIPE_MESSAGE_TYPE_LOG), pbData, cbData, NULL, NULL, &dwResult);
+        if (SUCCEEDED(hr))
+        {
+            hr = (HRESULT)dwResult;
+        }
+    }
+
+LExit:
+    ReleaseBuffer(pbData);
+
+    // We started logging so remember to say we are no longer logging.
+    if (fStartedLogging)
+    {
+        s_fCurrentlyLoggingToPipe = FALSE;
+    }
+
+    return hr;
+}
+
+static HRESULT Restart()
+{
+    HRESULT hr = S_OK;
+    HANDLE hProcessToken = NULL;
+    TOKEN_PRIVILEGES priv = { };
+    DWORD dwRetries = 0;
+
+    if (!::OpenProcessToken(::GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES, &hProcessToken))
+    {
+        ExitWithLastError(hr, "Failed to get process token.");
+    }
+
+    priv.PrivilegeCount = 1;
+    priv.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
+    if (!::LookupPrivilegeValueW(NULL, L"SeShutdownPrivilege", &priv.Privileges[0].Luid))
+    {
+        ExitWithLastError(hr, "Failed to get shutdown privilege LUID.");
+    }
+
+    if (!::AdjustTokenPrivileges(hProcessToken, FALSE, &priv, sizeof(TOKEN_PRIVILEGES), NULL, 0))
+    {
+        ExitWithLastError(hr, "Failed to adjust token to add shutdown privileges.");
+    }
+
+    do
+    {
+        hr = S_OK;
+
+        // Wait a second to let the companion process (assuming we did an elevated install) to get to the
+        // point where it too is thinking about restarting the computer. Only one will schedule the restart
+        // but both will have their log files closed and otherwise be ready to exit.
+        //
+        // On retry, we'll also wait a second to let the OS try to get to a place where the restart can
+        // be initiated.
+        ::Sleep(1000);
+
+        if (!vpfnInitiateSystemShutdownExW(NULL, NULL, 0, FALSE, TRUE, SHTDN_REASON_MAJOR_APPLICATION | SHTDN_REASON_MINOR_INSTALLATION | SHTDN_REASON_FLAG_PLANNED))
+        {
+            hr = HRESULT_FROM_WIN32(::GetLastError());
+        }
+    } while (dwRetries++ < RESTART_RETRIES && (HRESULT_FROM_WIN32(ERROR_MACHINE_LOCKED) == hr || HRESULT_FROM_WIN32(ERROR_NOT_READY) == hr));
+    ExitOnRootFailure(hr, "Failed to schedule restart.");
+
+LExit:
+    ReleaseHandle(hProcessToken);
+    return hr;
+}
diff --git a/src/engine/engine.mc b/src/engine/engine.mc
new file mode 100644
index 00000000..fb2dd6e9
--- /dev/null
+++ b/src/engine/engine.mc
@@ -0,0 +1,901 @@
+; // 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.
+
+
+MessageIdTypedef=DWORD
+
+LanguageNames=(English=0x409:MSG00409)
+
+
+; // message definitions
+
+; // MessageId=#
+; // Severity=Success
+; // SymbolicName=MSG_SUCCESS
+; // Language=English
+; // Success %1.
+; // .
+;
+; // MessageId=#
+; // Severity=Warning
+; // SymbolicName=MSG_WARNING
+; // Language=English
+; // Warning %1.
+; // .
+;
+; // MessageId=#
+; // Severity=Error
+; // SymbolicName=MSG_ERROR
+; // Language=English
+; // Error %1.
+; // .
+
+MessageId=1
+Severity=Success
+SymbolicName=MSG_BURN_INFO
+Language=English
+Burn v%1!hs!, Windows v%2!d!.%3!d! (Build %4!d!: Service Pack %5!d!), path: %6!ls!
+.
+
+MessageId=2
+Severity=Warning
+SymbolicName=MSG_BURN_UNKNOWN_PRIVATE_SWITCH
+Language=English
+Unknown burn internal command-line switch encountered: '%1!ls!'.
+.
+
+MessageId=3
+Severity=Success
+SymbolicName=MSG_BURN_RUN_BY_RELATED_BUNDLE
+Language=English
+This bundle is being run by a related bundle as type '%1!hs!'.
+.
+
+MessageId=4
+Severity=Success
+SymbolicName=MSG_BA_REQUESTED_RESTART
+Language=English
+Bootstrapper application requested restart at shutdown. Planned to restart already: %1!hs!.
+.
+
+MessageId=5
+Severity=Warning
+SymbolicName=MSG_RESTARTING
+Language=English
+Restarting computer...
+=======================================
+.
+
+MessageId=6
+Severity=Success
+SymbolicName=MSG_BA_REQUESTED_RELOAD
+Language=English
+Bootstrapper application requested to be reloaded.
+.
+
+MessageId=7
+Severity=Success
+SymbolicName=MSG_EXITING
+Language=English
+Exit code: 0x%1!x!, restarting: %2!hs!
+.
+
+MessageId=8
+Severity=Warning
+SymbolicName=MSG_RESTART_ABORTED
+Language=English
+Preventing requested restart because bundle is related: '%1!hs!'. Returning restart requested to parent bundle.
+.
+
+MessageId=9
+Severity=Success
+SymbolicName=MSG_BURN_COMMAND_LINE
+Language=English
+Command Line: '%1!ls!'
+.
+
+MessageId=10
+Severity=Success
+SymbolicName=MSG_LAUNCH_ELEVATED_ENGINE_STARTING
+Language=English
+Launching elevated engine process.
+.
+
+MessageId=11
+Severity=Success
+SymbolicName=MSG_LAUNCH_ELEVATED_ENGINE_SUCCESS
+Language=English
+Launched elevated engine process.
+.
+
+MessageId=12
+Severity=Success
+SymbolicName=MSG_CONNECT_TO_ELEVATED_ENGINE_SUCCESS
+Language=English
+Connected to elevated engine.
+.
+
+MessageId=51
+Severity=Error
+SymbolicName=MSG_FAILED_PARSE_CONDITION
+Language=English
+Error %1!hs!. Failed to parse condition %2!ls!. Unexpected symbol at position %3!hs!
+.
+
+MessageId=52
+Severity=Success
+SymbolicName=MSG_CONDITION_RESULT
+Language=English
+Condition '%1!ls!' evaluates to %2!hs!.
+.
+
+MessageId=53
+Severity=Error
+SymbolicName=MSG_FAILED_CONDITION_CHECK
+Language=English
+Bundle global condition check didn't succeed - aborting without loading application.
+.
+
+MessageId=54
+Severity=Error
+SymbolicName=MSG_PAYLOAD_FILE_NOT_PRESENT
+Language=English
+Failed to resolve source for file: %2!ls!, error: %1!ls!.
+.
+
+MessageId=55
+Severity=Warning
+SymbolicName=MSG_CANNOT_LOAD_STATE_FILE
+Language=English
+Could not load or read state file: %2!ls!, error: 0x%1!x!.
+.
+
+MessageId=56
+Severity=Error
+SymbolicName=MSG_USER_CANCELED
+Language=English
+Application canceled operation: %2!ls!, error: %1!ls!
+.
+
+MessageId=100
+Severity=Success
+SymbolicName=MSG_DETECT_BEGIN
+Language=English
+Detect begin, %1!u! packages
+.
+
+MessageId=101
+Severity=Success
+SymbolicName=MSG_DETECTED_PACKAGE
+Language=English
+Detected package: %1!ls!, state: %2!hs!, cached: %3!hs!
+.
+
+MessageId=102
+Severity=Success
+SymbolicName=MSG_DETECTED_RELATED_BUNDLE
+Language=English
+Detected related bundle: %1!ls!, type: %2!hs!, scope: %3!hs!, version: %4!hs!, operation: %5!hs!
+.
+
+MessageId=103
+Severity=Success
+SymbolicName=MSG_DETECTED_RELATED_PACKAGE
+Language=English
+Detected related package: %1!ls!, scope: %2!hs!, version: %3!hs!, language: %4!u! operation: %5!hs!
+.
+
+MessageId=104
+Severity=Success
+SymbolicName=MSG_DETECTED_MSI_FEATURE
+Language=English
+Detected package: %1!ls!, feature: %2!ls!, state: %3!hs!
+.
+
+MessageId=105
+Severity=Success
+SymbolicName=MSG_DETECTED_MSP_TARGET
+Language=English
+Detected package: %1!ls! target: %2!ls!, state: %3!hs!
+.
+
+MessageId=106
+Severity=Success
+SymbolicName=MSG_DETECT_CALCULATE_PATCH_APPLICABILITY
+Language=English
+Calculating patch applicability for target product code: %1!ls!, context: %2!hs!
+.
+
+MessageId=107
+Severity=Success
+SymbolicName=MSG_DETECTED_FORWARD_COMPATIBLE_BUNDLE
+Language=English
+Detected forward compatible bundle: %1!ls!, type: %2!hs!, scope: %3!hs!, version: %4!hs!, enabled: %5!hs!
+.
+
+MessageId=108
+Severity=Success
+SymbolicName=MSG_DETECTED_COMPATIBLE_PACKAGE_FROM_PROVIDER
+Language=English
+Detected compatible package: %1!ls!, provider: %2!ls!, installed: %3!ls!, version: %4!ls!, chained: %5!ls!
+.
+
+MessageId=120
+Severity=Warning
+SymbolicName=MSG_DETECT_PACKAGE_NOT_FULLY_CACHED
+Language=English
+Detected partially cached package: %1!ls!, invalid payload: %2!ls!, reason: 0x%3!x!
+.
+
+MessageId=121
+Severity=Warning
+SymbolicName=MSG_DETECT_FAILED_CALCULATE_PATCH_APPLICABILITY
+Language=English
+Could not calculate patch applicability for target product code: %1!ls!, context: %2!hs!, reason: 0x%3!x!
+.
+
+MessageId=151
+Severity=Error
+SymbolicName=MSG_FAILED_DETECT_PACKAGE
+Language=English
+Detect failed for package: %2!ls!, error: %1!ls!
+.
+
+MessageId=152
+Severity=Error
+SymbolicName=MSG_FAILED_READ_RELATED_PACKAGE_LANGUAGE
+Language=English
+Detected related package: %2!ls!, but failed to read language: %3!hs!, error: 0x%1!x!
+.
+
+MessageId=170
+Severity=Warning
+SymbolicName=MSG_DETECT_BAD_PRODUCT_CONFIGURATION
+Language=English
+Detected bad configuration for product: %1!ls!
+.
+
+MessageId=199
+Severity=Success
+SymbolicName=MSG_DETECT_COMPLETE
+Language=English
+Detect complete, result: 0x%1!x!
+.
+
+MessageId=200
+Severity=Success
+SymbolicName=MSG_PLAN_BEGIN
+Language=English
+Plan begin, %1!u! packages, action: %2!hs!
+.
+
+MessageId=201
+Severity=Success
+SymbolicName=MSG_PLANNED_PACKAGE
+Language=English
+Planned package: %1!ls!, state: %2!hs!, default requested: %3!hs!, ba requested: %4!hs!, execute: %5!hs!, rollback: %6!hs!, cache: %7!hs!, uncache: %8!hs!, dependency: %9!hs!
+.
+
+MessageId=202
+Severity=Success
+SymbolicName=MSG_PLANNED_BUNDLE_UX_CHANGED_REQUEST
+Language=English
+Planned bundle: %1!ls!, ba requested state: %2!hs! over default: %3!hs!
+.
+
+MessageId=203
+Severity=Success
+SymbolicName=MSG_PLANNED_MSI_FEATURE
+Language=English
+Planned feature: %1!ls!, state: %2!hs!, default requested: %3!hs!, ba requested: %4!hs!, execute action: %5!hs!, rollback action: %6!hs!
+.
+
+MessageId=204
+Severity=Success
+SymbolicName=MSG_PLAN_MSI_FEATURES
+Language=English
+Plan %1!u! msi features for package: %2!ls!
+.
+
+MessageId=205
+Severity=Warning
+SymbolicName=MSG_PLAN_SKIP_PATCH_ACTION
+Language=English
+Plan %5!hs! skipped patch: %1!ls!, action: %2!hs! because chained target package: %3!ls! being uninstalled
+.
+
+MessageId=206
+Severity=Warning
+SymbolicName=MSG_PLAN_SKIP_SLIPSTREAM_ACTION
+Language=English
+Plan %5!hs! skipped patch: %1!ls!, action: %2!hs! because slipstreamed into chained target package: %3!ls!, action: %4!hs!
+.
+
+MessageId=207
+Severity=Success
+SymbolicName=MSG_PLANNED_RELATED_BUNDLE
+Language=English
+Planned related bundle: %1!ls!, type: %2!hs!, default requested: %3!hs!, ba requested: %4!hs!, execute: %5!hs!, rollback: %6!hs!, dependency: %7!hs!
+.
+
+MessageId=208
+Severity=Warning
+SymbolicName=MSG_PLAN_DISABLING_ROLLBACK_NO_CACHE
+Language=English
+Plan disabled rollback for package: %1!ls!, due to incomplete cache: %2!hs!, original rollback action: %3!hs!
+.
+
+MessageId=209
+Severity=Warning
+SymbolicName=MSG_PLAN_SKIPPED_PROVIDER_KEY_REMOVAL
+Language=English
+Plan skipped removal of provider key: %1!ls! because it is registered to a different bundle: %2!ls!
+.
+
+MessageId=210
+Severity=Warning
+SymbolicName=MSG_PLAN_SKIPPED_DUE_TO_DEPENDENTS
+Language=English
+Plan skipped due to %1!u! remaining dependents
+.
+
+MessageId=211
+Severity=Success
+SymbolicName=MSG_PLANNED_UPGRADE_BUNDLE
+Language=English
+Planned upgrade bundle: %1!ls!, default requested: %2!hs!, ba requested: %3!hs!, execute: %4!hs!, rollback: %5!hs!, dependency: %6!hs!
+.
+
+MessageId=212
+Severity=Success
+SymbolicName=MSG_PLANNED_FORWARD_COMPATIBLE_BUNDLE
+Language=English
+Planned forward compatible bundle: %1!ls!, default requested: %2!hs!, ba requested: %3!hs!, execute: %4!hs!, rollback: %5!hs!, dependency: %6!hs!
+.
+
+MessageId=213
+Severity=Success
+SymbolicName=MSG_PLAN_SKIPPED_RELATED_BUNDLE_DEPENDENT
+Language=English
+Plan skipped related bundle: %1!ls!, type: %2!hs!, because it was dependent and the current bundle is being executed as type: %3!hs!.
+.
+
+MessageId=214
+Severity=Success
+SymbolicName=MSG_PLAN_SKIPPED_RELATED_BUNDLE_SCHEDULED
+Language=English
+Plan skipped related bundle: %1!ls!, type: %2!hs!, because it was previously scheduled.
+.
+
+MessageId=215
+Severity=Success
+SymbolicName=MSG_PLANNED_ORPHAN_PACKAGE_FROM_PROVIDER
+Language=English
+Will remove orphan package: %1!ls!, installed: %2!ls!, chained: %3!ls!
+.
+
+MessageId=216
+Severity=Success
+SymbolicName=MSG_PLAN_SKIPPED_RELATED_BUNDLE_EMBEDDED_BUNDLE_NEWER
+Language=English
+Plan skipped related bundle: %1!ls!, type: %2!hs!, provider key: %3!ls!, because an embedded bundle with the same provider key is being installed.
+.
+
+MessageId=217
+Severity=Success
+SymbolicName=MSG_PLAN_SKIPPED_DEPENDENT_BUNDLE_REPAIR
+Language=English
+Plan skipped dependent bundle repair: %1!ls!, type: %2!hs!, because no packages are being executed during this uninstall operation.
+.
+
+MessageId=299
+Severity=Success
+SymbolicName=MSG_PLAN_COMPLETE
+Language=English
+Plan complete, result: 0x%1!x!
+.
+
+MessageId=300
+Severity=Success
+SymbolicName=MSG_APPLY_BEGIN
+Language=English
+Apply begin
+.
+
+MessageId=301
+Severity=Success
+SymbolicName=MSG_APPLYING_PACKAGE
+Language=English
+Applying %1!hs! package: %2!ls!, action: %3!hs!, path: %4!ls!, arguments: '%5!ls!'
+.
+
+MessageId=302
+Severity=Success
+SymbolicName=MSG_ACQUIRED_PAYLOAD
+Language=English
+Acquired payload: %1!ls! to working path: %2!ls! from: %4!ls!.
+.
+
+MessageId=304
+Severity=Success
+SymbolicName=MSG_VERIFIED_EXISTING_PAYLOAD
+Language=English
+Verified existing payload: %1!ls! at path: %2!ls!.
+.
+
+MessageId=305
+Severity=Success
+SymbolicName=MSG_VERIFIED_ACQUIRED_PAYLOAD
+Language=English
+Verified acquired payload: %1!ls! at path: %2!ls!, %3!hs! to: %4!ls!.
+.
+
+MessageId=306
+Severity=Success
+SymbolicName=MSG_APPLYING_PATCH_PACKAGE
+Language=English
+Applying package: %1!ls!, target: %5!ls!, action: %2!hs!, path: %3!ls!, arguments: '%4!ls!'
+.
+
+MessageId=307
+Severity=Warning
+SymbolicName=MSG_ATTEMPTED_UNINSTALL_ABSENT_PACKAGE
+Language=English
+Attempted to uninstall absent package: %1!ls!. Continuing...
+.
+
+MessageId=308
+Severity=Warning
+SymbolicName=MSG_FAILED_PAUSE_AU
+Language=English
+Automatic updates could not be paused due to error: 0x%1!x!. Continuing...
+.
+
+MessageId=309
+Severity=Warning
+SymbolicName=MSG_APPLY_SKIPPED_FAILED_CACHED_PACKAGE
+Language=English
+Skipping apply of package: %1!ls! due to cache error: 0x%2!x!. Continuing...
+.
+
+MessageId=310
+Severity=Error
+SymbolicName=MSG_FAILED_VERIFY_PAYLOAD
+Language=English
+Failed to verify payload: %2!ls! at path: %3!ls!, error: %1!ls!. Deleting file.
+.
+
+MessageId=311
+Severity=Error
+SymbolicName=MSG_FAILED_ACQUIRE_CONTAINER
+Language=English
+Failed to acquire container: %2!ls! to working path: %3!ls!, error: %1!ls!.
+.
+
+MessageId=312
+Severity=Error
+SymbolicName=MSG_FAILED_EXTRACT_CONTAINER
+Language=English
+Failed to extract payloads from container: %2!ls! to working path: %3!ls!, error: %1!ls!.
+.
+
+MessageId=313
+Severity=Error
+SymbolicName=MSG_FAILED_ACQUIRE_PAYLOAD
+Language=English
+Failed to acquire payload: %2!ls! to working path: %3!ls!, error: %1!ls!.
+.
+
+MessageId=314
+Severity=Error
+SymbolicName=MSG_FAILED_CACHE_PAYLOAD
+Language=English
+Failed to cache payload: %2!ls! from working path: %3!ls!, error: %1!ls!.
+.
+
+MessageId=315
+Severity=Error
+SymbolicName=MSG_FAILED_LAYOUT_BUNDLE
+Language=English
+Failed to layout bundle: %2!ls! to layout directory: %3!ls!, error: %1!ls!.
+.
+
+MessageId=316
+Severity=Error
+SymbolicName=MSG_FAILED_LAYOUT_CONTAINER
+Language=English
+Failed to layout container: %2!ls! to layout directory: %3!ls!, error: %1!ls!.
+.
+
+
+MessageId=317
+Severity=Error
+SymbolicName=MSG_FAILED_LAYOUT_PAYLOAD
+Language=English
+Failed to layout payload: %2!ls! to layout directory: %3!ls!, error: %1!ls!.
+.
+
+MessageId=318
+Severity=Success
+SymbolicName=MSG_ROLLBACK_PACKAGE_SKIPPED
+Language=English
+Skipped rollback of package: %1!ls!, action: %2!hs!, already: %3!hs!
+.
+
+MessageId=319
+Severity=Success
+SymbolicName=MSG_APPLY_COMPLETED_PACKAGE
+Language=English
+Applied %1!hs! package: %2!ls!, result: 0x%3!x!, restart: %4!hs!
+.
+
+MessageId=320
+Severity=Success
+SymbolicName=MSG_DEPENDENCY_BUNDLE_REGISTER
+Language=English
+Registering bundle dependency provider: %1!ls!, version: %2!ls!
+.
+
+MessageId=321
+Severity=Warning
+SymbolicName=MSG_DEPENDENCY_PACKAGE_SKIP_NOPROVIDERS
+Language=English
+Skipping dependency registration on package with no dependency providers: %1!ls!
+.
+
+MessageId=322
+Severity=Warning
+SymbolicName=MSG_DEPENDENCY_PACKAGE_SKIP_WRONGSCOPE
+Language=English
+Skipping cross-scope dependency registration on package: %1!ls!, bundle scope: %2!hs!, package scope: %3!hs!
+.
+
+MessageId=323
+Severity=Success
+SymbolicName=MSG_DEPENDENCY_PACKAGE_REGISTER
+Language=English
+Registering package dependency provider: %1!ls!, version: %2!ls!, package: %3!ls!
+.
+
+MessageId=324
+Severity=Warning
+SymbolicName=MSG_DEPENDENCY_PACKAGE_SKIP_MISSING
+Language=English
+Skipping dependency registration on missing package provider: %1!ls!, package: %2!ls!
+.
+
+MessageId=325
+Severity=Success
+SymbolicName=MSG_DEPENDENCY_PACKAGE_REGISTER_DEPENDENCY
+Language=English
+Registering dependency: %1!ls! on package provider: %2!ls!, package: %3!ls!
+.
+
+MessageId=326
+Severity=Success
+SymbolicName=MSG_DEPENDENCY_PACKAGE_UNREGISTERED_DEPENDENCY
+Language=English
+Removed dependency: %1!ls! on package provider: %2!ls!, package %3!ls!
+.
+
+MessageId=327
+Severity=Warning
+SymbolicName=MSG_DEPENDENCY_PACKAGE_HASDEPENDENTS
+Language=English
+Will not uninstall package: %1!ls!, found dependents: %2!d!
+.
+
+MessageId=328
+Severity=Warning
+SymbolicName=MSG_DEPENDENCY_PACKAGE_DEPENDENT
+Language=English
+Found dependent: %1!ls!, name: %2!ls!
+.
+
+MessageId=329
+Severity=Success
+SymbolicName=MSG_DEPENDENCY_PACKAGE_UNREGISTERED
+Language=English
+Removed package dependency provider: %1!ls!, package: %2!ls!
+.
+
+MessageId=330
+Severity=Success
+SymbolicName=MSG_DEPENDENCY_BUNDLE_UNREGISTERED
+Language=English
+Removed bundle dependency provider: %1!ls!
+.
+
+MessageId=331
+Severity=Warning
+SymbolicName=MSG_DEPENDENCY_PACKAGE_UNREGISTERED_DEPENDENCY_FAILED
+Language=English
+Could not remove dependency: %1!ls! on package provider: %2!ls!, package %3!ls!, error: 0x%4!x!
+.
+
+MessageId=332
+Severity=Warning
+SymbolicName=MSG_DEPENDENCY_PACKAGE_UNREGISTERED_FAILED
+Language=English
+Could not remove package dependency provider: %1!ls!, package: %2!ls!, error: 0x%3!x!
+.
+
+MessageId=333
+Severity=Warning
+SymbolicName=MSG_DEPENDENCY_BUNDLE_UNREGISTERED_FAILED
+Language=English
+Could not remove bundle dependency provider: %1!ls!, error: 0x%2!x!
+.
+
+MessageId=335
+Severity=Success
+SymbolicName=MSG_ACQUIRE_BUNDLE_PAYLOAD
+Language=English
+Acquiring bundle payload: %2!ls!, %3!hs! from: %4!ls!
+.
+
+MessageId=336
+Severity=Success
+SymbolicName=MSG_ACQUIRE_CONTAINER
+Language=English
+Acquiring container: %1!ls!, %3!hs! from: %4!ls!
+.
+
+MessageId=337
+Severity=Success
+SymbolicName=MSG_ACQUIRE_CONTAINER_PAYLOAD
+Language=English
+Acquiring container: %1!ls!, payload: %2!ls!, %3!hs! from: %4!ls!
+.
+
+MessageId=338
+Severity=Success
+SymbolicName=MSG_ACQUIRE_PACKAGE_PAYLOAD
+Language=English
+Acquiring package: %1!ls!, payload: %2!ls!, %3!hs! from: %4!ls!
+.
+
+MessageId=340
+Severity=Warning
+SymbolicName=MSG_PROMPT_BUNDLE_PAYLOAD_SOURCE
+Language=English
+Prompt for source of bundle payload: %2!ls!, path: %3!ls!
+.
+
+MessageId=341
+Severity=Warning
+SymbolicName=MSG_PROMPT_CONTAINER_SOURCE
+Language=English
+Prompt for source of container: %1!ls!, path: %3!ls!
+.
+
+MessageId=342
+Severity=Warning
+SymbolicName=MSG_PROMPT_CONTAINER_PAYLOAD_SOURCE
+Language=English
+Prompt for source of container: %1!ls!, payload: %2!ls!, path: %3!ls!
+.
+
+MessageId=343
+Severity=Warning
+SymbolicName=MSG_PROMPT_PACKAGE_PAYLOAD_SOURCE
+Language=English
+Prompt for source of package: %1!ls!, payload: %2!ls!, path: %3!ls!
+.
+
+MessageId=348
+Severity=Warning
+SymbolicName=MSG_APPLY_RETRYING_PACKAGE
+Language=English
+Application requested retry of package: %1!ls!, encountered error: 0x%2!x!. Retrying...
+.
+
+MessageId=349
+Severity=Warning
+SymbolicName=MSG_APPLY_RETRYING_PAYLOAD
+Language=English
+Application requested retry of payload: %2!ls!, encountered error: %1!ls!. Retrying...
+.
+
+MessageId=350
+Severity=Warning
+SymbolicName=MSG_APPLY_CONTINUING_NONVITAL_PACKAGE
+Language=English
+Applied non-vital package: %1!ls!, encountered error: 0x%2!x!. Continuing...
+.
+
+MessageId=351
+Severity=Success
+SymbolicName=MSG_UNCACHE_PACKAGE
+Language=English
+Removing cached package: %1!ls!, from path: %2!ls!
+.
+
+MessageId=352
+Severity=Success
+SymbolicName=MSG_UNCACHE_BUNDLE
+Language=English
+Removing cached bundle: %1!ls!, from path: %2!ls!
+.
+
+MessageId=353
+Severity=Warning
+SymbolicName=MSG_UNABLE_UNCACHE_PACKAGE
+Language=English
+Unable to remove cached package: %1!ls!, from path: %2!ls!, reason: 0x%3!x!. Continuing...
+.
+
+MessageId=354
+Severity=Warning
+SymbolicName=MSG_UNABLE_UNCACHE_BUNDLE
+Language=English
+Unable to remove cached bundle: %1!ls!, from path: %2!ls!, reason: 0x%3!x!. Continuing...
+.
+
+MessageId=355
+Severity=Warning
+SymbolicName=MSG_SOURCELIST_REGISTER
+Language=English
+Unable to register source directory: %1!ls!, product: %2!ls!, reason: 0x%3!x!. Continuing...
+.
+
+MessageId=358
+Severity=Success
+SymbolicName=MSG_PAUSE_AU_STARTING
+Language=English
+Pausing automatic updates.
+.
+
+MessageId=359
+Severity=Success
+SymbolicName=MSG_PAUSE_AU_SUCCEEDED
+Language=English
+Paused automatic updates.
+.
+
+MessageId=360
+Severity=Success
+SymbolicName=MSG_SYSTEM_RESTORE_POINT_STARTING
+Language=English
+Creating a system restore point.
+.
+
+MessageId=361
+Severity=Success
+SymbolicName=MSG_SYSTEM_RESTORE_POINT_SUCCEEDED
+Language=English
+Created a system restore point.
+.
+
+MessageId=362
+Severity=Success
+SymbolicName=MSG_SYSTEM_RESTORE_POINT_DISABLED
+Language=English
+System restore disabled, system restore point not created.
+.
+
+MessageId=363
+Severity=Warning
+SymbolicName=MSG_SYSTEM_RESTORE_POINT_FAILED
+Language=English
+Could not create system restore point, error: 0x%1!x!. Continuing...
+.
+
+MessageId=370
+Severity=Success
+SymbolicName=MSG_SESSION_BEGIN
+Language=English
+Session begin, registration key: %1!ls!, options: 0x%2!x!, disable resume: %3!hs!
+.
+
+MessageId=371
+Severity=Success
+SymbolicName=MSG_SESSION_UPDATE
+Language=English
+Updating session, registration key: %1!ls!, resume: %2!hs!, restart initiated: %3!hs!, disable resume: %4!hs!
+.
+
+MessageId=372
+Severity=Success
+SymbolicName=MSG_SESSION_END
+Language=English
+Session end, registration key: %1!ls!, resume: %2!hs!, restart: %3!hs!, disable resume: %4!hs!
+.
+
+MessageId=380
+Severity=Warning
+SymbolicName=MSG_APPLY_SKIPPED
+Language=English
+Apply skipped, no planned actions
+.
+
+MessageId=381
+Severity=Warning
+SymbolicName=MSG_APPLY_CANCEL_IGNORED_DURING_ROLLBACK
+Language=English
+Ignoring application request to cancel from %1!ls! during rollback. 
+.
+
+MessageId=399
+Severity=Success
+SymbolicName=MSG_APPLY_COMPLETE
+Language=English
+Apply complete, result: 0x%1!x!, restart: %2!hs!, ba requested restart:  %3!hs!
+.
+
+MessageId=400
+Severity=Success
+SymbolicName=MSG_SYSTEM_SHUTDOWN
+Language=English
+Received system request to shut down the process: critical: %1!hs!, elevated: %2!hs!, allowed: %3!hs!
+.
+
+MessageId=410
+Severity=Success
+SymbolicName=MSG_VARIABLE_DUMP
+Language=English
+Variable: %1!ls!
+.
+
+MessageId=420
+Severity=Success
+SymbolicName=MSG_RESUME_AU_STARTING
+Language=English
+Resuming automatic updates.
+.
+
+MessageId=421
+Severity=Success
+SymbolicName=MSG_RESUME_AU_SUCCEEDED
+Language=English
+Resumed automatic updates.
+.
+
+MessageId=500
+Severity=Success
+SymbolicName=MSG_QUIT
+Language=English
+Shutting down, exit code: 0x%1!x!
+.
+
+MessageId=501
+Severity=Warning
+SymbolicName=MSG_STATE_NOT_SAVED
+Language=English
+The state file could not be saved, error: 0x%1!x!. Continuing...
+.
+
+MessageId=600
+Severity=Success
+SymbolicName=MSG_LAUNCH_APPROVED_EXE_BEGIN
+Language=English
+LaunchApprovedExe begin, id: %1!ls!
+.
+
+MessageId=601
+Severity=Success
+SymbolicName=MSG_LAUNCH_APPROVED_EXE_SEARCH
+Language=English
+Searching registry for approved exe path, key: %1!ls!, value: '%2!ls!', win64: %3!ls!
+.
+
+MessageId=602
+Severity=Success
+SymbolicName=MSG_LAUNCHING_APPROVED_EXE
+Language=English
+Launching approved exe, path: '%1!ls!', 'command: %2!ls!'
+.
+
+MessageId=699
+Severity=Success
+SymbolicName=MSG_LAUNCH_APPROVED_EXE_COMPLETE
+Language=English
+LaunchApprovedExe complete, result: 0x%1!x!, processId: %2!lu!
+.
+
+MessageId=700
+Severity=Success
+SymbolicName=MSG_MSI_PROPERTY_CONDITION_FAILED
+Language=English
+Skipping MSI property '%1!ls!' because condition '%2!ls!' evaluates to %3!hs!.
+.
+
diff --git a/src/engine/exeengine.cpp b/src/engine/exeengine.cpp
new file mode 100644
index 00000000..71540d5d
--- /dev/null
+++ b/src/engine/exeengine.cpp
@@ -0,0 +1,820 @@
+// 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.
+
+#include "precomp.h"
+
+
+// internal function declarations
+
+static HRESULT HandleExitCode(
+    __in BURN_PACKAGE* pPackage,
+    __in DWORD dwExitCode,
+    __out BOOTSTRAPPER_APPLY_RESTART* pRestart
+    );
+static HRESULT ParseCommandLineArgumentsFromXml(
+    __in IXMLDOMNode* pixnExePackage,
+    __in BURN_PACKAGE* pPackage
+    );
+static HRESULT ParseExitCodesFromXml(
+    __in IXMLDOMNode* pixnExePackage,
+    __in BURN_PACKAGE* pPackage
+    );
+
+
+// function definitions
+
+extern "C" HRESULT ExeEngineParsePackageFromXml(
+    __in IXMLDOMNode* pixnExePackage,
+    __in BURN_PACKAGE* pPackage
+    )
+{
+    HRESULT hr = S_OK;
+    IXMLDOMNodeList* pixnNodes = NULL;
+    IXMLDOMNode* pixnNode = NULL;
+    LPWSTR scz = NULL;
+
+    // @DetectCondition
+    hr = XmlGetAttributeEx(pixnExePackage, L"DetectCondition", &pPackage->Exe.sczDetectCondition);
+    ExitOnFailure(hr, "Failed to get @DetectCondition.");
+
+    // @InstallArguments
+    hr = XmlGetAttributeEx(pixnExePackage, L"InstallArguments", &pPackage->Exe.sczInstallArguments);
+    ExitOnFailure(hr, "Failed to get @InstallArguments.");
+
+    // @UninstallArguments
+    hr = XmlGetAttributeEx(pixnExePackage, L"UninstallArguments", &pPackage->Exe.sczUninstallArguments);
+    ExitOnFailure(hr, "Failed to get @UninstallArguments.");
+
+    // @RepairArguments
+    hr = XmlGetAttributeEx(pixnExePackage, L"RepairArguments", &pPackage->Exe.sczRepairArguments);
+    ExitOnFailure(hr, "Failed to get @RepairArguments.");
+
+    // @Repairable
+    hr = XmlGetYesNoAttribute(pixnExePackage, L"Repairable", &pPackage->Exe.fRepairable);
+    if (E_NOTFOUND != hr)
+    {
+        ExitOnFailure(hr, "Failed to get @Repairable.");
+    }
+
+    // @Protocol
+    hr = XmlGetAttributeEx(pixnExePackage, L"Protocol", &scz);
+    if (SUCCEEDED(hr))
+    {
+        if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, scz, -1, L"burn", -1))
+        {
+            pPackage->Exe.protocol = BURN_EXE_PROTOCOL_TYPE_BURN;
+        }
+        else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, scz, -1, L"netfx4", -1))
+        {
+            pPackage->Exe.protocol = BURN_EXE_PROTOCOL_TYPE_NETFX4;
+        }
+        else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, scz, -1, L"none", -1))
+        {
+            pPackage->Exe.protocol = BURN_EXE_PROTOCOL_TYPE_NONE;
+        }
+        else
+        {
+            hr = E_UNEXPECTED;
+            ExitOnFailure(hr, "Invalid protocol type: %ls", scz);
+        }
+    }
+    else if (E_NOTFOUND != hr)
+    {
+        ExitOnFailure(hr, "Failed to get @Protocol.");
+    }
+
+    hr = ParseExitCodesFromXml(pixnExePackage, pPackage);
+    ExitOnFailure(hr, "Failed to parse exit codes.");
+
+    hr = ParseCommandLineArgumentsFromXml(pixnExePackage, pPackage);
+    ExitOnFailure(hr, "Failed to parse command lines.");
+
+LExit:
+    ReleaseObject(pixnNodes);
+    ReleaseObject(pixnNode);
+    ReleaseStr(scz);
+
+    return hr;
+}
+
+extern "C" void ExeEnginePackageUninitialize(
+    __in BURN_PACKAGE* pPackage
+    )
+{
+    ReleaseStr(pPackage->Exe.sczDetectCondition);
+    ReleaseStr(pPackage->Exe.sczInstallArguments);
+    ReleaseStr(pPackage->Exe.sczRepairArguments);
+    ReleaseStr(pPackage->Exe.sczUninstallArguments);
+    ReleaseStr(pPackage->Exe.sczIgnoreDependencies);
+    ReleaseStr(pPackage->Exe.sczAncestors);
+    //ReleaseStr(pPackage->Exe.sczProgressSwitch);
+    ReleaseMem(pPackage->Exe.rgExitCodes);
+
+    // free command-line arguments
+    if (pPackage->Exe.rgCommandLineArguments)
+    {
+        for (DWORD i = 0; i < pPackage->Exe.cCommandLineArguments; ++i)
+        {
+            BURN_EXE_COMMAND_LINE_ARGUMENT* pCommandLineArgument = &pPackage->Exe.rgCommandLineArguments[i];
+            ReleaseStr(pCommandLineArgument->sczInstallArgument);
+            ReleaseStr(pCommandLineArgument->sczUninstallArgument);
+            ReleaseStr(pCommandLineArgument->sczRepairArgument);
+            ReleaseStr(pCommandLineArgument->sczCondition);
+        }
+        MemFree(pPackage->Exe.rgCommandLineArguments);
+    }
+
+    // clear struct
+    memset(&pPackage->Exe, 0, sizeof(pPackage->Exe));
+}
+
+extern "C" HRESULT ExeEngineDetectPackage(
+    __in BURN_PACKAGE* pPackage,
+    __in BURN_VARIABLES* pVariables
+    )
+{
+    HRESULT hr = S_OK;
+    BOOL fDetected = FALSE;
+
+    // evaluate detect condition
+    if (pPackage->Exe.sczDetectCondition && *pPackage->Exe.sczDetectCondition)
+    {
+        hr = ConditionEvaluate(pVariables, pPackage->Exe.sczDetectCondition, &fDetected);
+        ExitOnFailure(hr, "Failed to evaluate executable package detect condition.");
+    }
+
+    // update detect state
+    pPackage->currentState = fDetected ? BOOTSTRAPPER_PACKAGE_STATE_PRESENT : BOOTSTRAPPER_PACKAGE_STATE_ABSENT;
+
+LExit:
+    return hr;
+}
+
+//
+// PlanCalculate - calculates the execute and rollback state for the requested package state.
+//
+extern "C" HRESULT ExeEnginePlanCalculatePackage(
+    __in BURN_PACKAGE* pPackage,
+    __out_opt BOOL* pfBARequestedCache
+    )
+{
+    HRESULT hr = S_OK;
+    //BOOL fCondition = FALSE;
+    //BOOTSTRAPPER_PACKAGE_STATE expected = BOOTSTRAPPER_PACKAGE_STATE_UNKNOWN;
+    BOOTSTRAPPER_ACTION_STATE execute = BOOTSTRAPPER_ACTION_STATE_NONE;
+    BOOTSTRAPPER_ACTION_STATE rollback = BOOTSTRAPPER_ACTION_STATE_NONE;
+    BOOL fBARequestedCache = FALSE;
+
+    //// evaluate rollback install condition
+    //if (pPackage->sczRollbackInstallCondition)
+    //{
+    //    hr = ConditionEvaluate(pVariables, pPackage->sczRollbackInstallCondition, &fCondition);
+    //    ExitOnFailure(hr, "Failed to evaluate rollback install condition.");
+
+    //    expected = fCondition ? BOOTSTRAPPER_PACKAGE_STATE_PRESENT : BOOTSTRAPPER_PACKAGE_STATE_ABSENT;
+    //}
+
+    // execute action
+    switch (pPackage->currentState)
+    {
+    case BOOTSTRAPPER_PACKAGE_STATE_PRESENT:
+        switch (pPackage->requested)
+        {
+        case BOOTSTRAPPER_REQUEST_STATE_PRESENT:
+            execute = pPackage->Exe.fPseudoBundle ? BOOTSTRAPPER_ACTION_STATE_INSTALL : BOOTSTRAPPER_ACTION_STATE_NONE;
+            break;
+        case BOOTSTRAPPER_REQUEST_STATE_REPAIR:
+            execute = pPackage->Exe.fRepairable ? BOOTSTRAPPER_ACTION_STATE_REPAIR : BOOTSTRAPPER_ACTION_STATE_NONE;
+            break;
+        case BOOTSTRAPPER_REQUEST_STATE_ABSENT: __fallthrough;
+        case BOOTSTRAPPER_REQUEST_STATE_CACHE:
+            execute = pPackage->fUninstallable ? BOOTSTRAPPER_ACTION_STATE_UNINSTALL : BOOTSTRAPPER_ACTION_STATE_NONE;
+            break;
+        case BOOTSTRAPPER_REQUEST_STATE_FORCE_ABSENT:
+            execute = BOOTSTRAPPER_ACTION_STATE_UNINSTALL;
+            break;
+        default:
+            execute = BOOTSTRAPPER_ACTION_STATE_NONE;
+            break;
+        }
+        break;
+
+    case BOOTSTRAPPER_PACKAGE_STATE_ABSENT:
+        switch (pPackage->requested)
+        {
+        case BOOTSTRAPPER_REQUEST_STATE_PRESENT: __fallthrough;
+        case BOOTSTRAPPER_REQUEST_STATE_REPAIR:
+            execute = BOOTSTRAPPER_ACTION_STATE_INSTALL;
+            break;
+        case BOOTSTRAPPER_REQUEST_STATE_CACHE:
+            execute = BOOTSTRAPPER_ACTION_STATE_NONE;
+            fBARequestedCache = TRUE;
+            break;
+        default:
+            execute = BOOTSTRAPPER_ACTION_STATE_NONE;
+            break;
+        }
+        break;
+
+    default:
+        hr = E_INVALIDARG;
+        ExitOnRootFailure(hr, "Invalid package current state: %d.", pPackage->currentState);
+    }
+
+    // Calculate the rollback action if there is an execute action.
+    if (BOOTSTRAPPER_ACTION_STATE_NONE != execute)
+    {
+        switch (BOOTSTRAPPER_PACKAGE_STATE_UNKNOWN != pPackage->expected ? pPackage->expected : pPackage->currentState)
+        {
+        case BOOTSTRAPPER_PACKAGE_STATE_PRESENT:
+            switch (pPackage->requested)
+            {
+            case BOOTSTRAPPER_REQUEST_STATE_PRESENT: __fallthrough;
+            case BOOTSTRAPPER_REQUEST_STATE_REPAIR:
+                rollback = BOOTSTRAPPER_ACTION_STATE_NONE;
+                break;
+            case BOOTSTRAPPER_REQUEST_STATE_FORCE_ABSENT: __fallthrough;
+            case BOOTSTRAPPER_REQUEST_STATE_ABSENT:
+                rollback = BOOTSTRAPPER_ACTION_STATE_INSTALL;
+                break;
+            default:
+                rollback = BOOTSTRAPPER_ACTION_STATE_NONE;
+                break;
+            }
+            break;
+
+        case BOOTSTRAPPER_PACKAGE_STATE_ABSENT:
+            switch (pPackage->requested)
+            {
+            case BOOTSTRAPPER_REQUEST_STATE_PRESENT: __fallthrough;
+            case BOOTSTRAPPER_REQUEST_STATE_REPAIR:
+                rollback = pPackage->fUninstallable ? BOOTSTRAPPER_ACTION_STATE_UNINSTALL : BOOTSTRAPPER_ACTION_STATE_NONE;
+                break;
+            case BOOTSTRAPPER_REQUEST_STATE_FORCE_ABSENT: __fallthrough;
+            case BOOTSTRAPPER_REQUEST_STATE_ABSENT:
+                rollback = BOOTSTRAPPER_ACTION_STATE_NONE;
+                break;
+            default:
+                rollback = BOOTSTRAPPER_ACTION_STATE_NONE;
+                break;
+            }
+            break;
+
+        default:
+            hr = E_INVALIDARG;
+            ExitOnRootFailure(hr, "Invalid package expected state.");
+        }
+    }
+
+    // return values
+    pPackage->execute = execute;
+    pPackage->rollback = rollback;
+
+    if (pfBARequestedCache)
+    {
+        *pfBARequestedCache = fBARequestedCache;
+    }
+
+LExit:
+    return hr;
+}
+
+//
+// PlanAdd - adds the calculated execute and rollback actions for the package.
+//
+extern "C" HRESULT ExeEnginePlanAddPackage(
+    __in_opt DWORD *pdwInsertSequence,
+    __in BURN_PACKAGE* pPackage,
+    __in BURN_PLAN* pPlan,
+    __in BURN_LOGGING* pLog,
+    __in BURN_VARIABLES* pVariables,
+    __in_opt HANDLE hCacheEvent,
+    __in BOOL fPlanPackageCacheRollback
+    )
+{
+    HRESULT hr = S_OK;
+    BURN_EXECUTE_ACTION* pAction = NULL;
+
+    // add wait for cache
+    if (hCacheEvent)
+    {
+        hr = PlanExecuteCacheSyncAndRollback(pPlan, pPackage, hCacheEvent, fPlanPackageCacheRollback);
+        ExitOnFailure(hr, "Failed to plan package cache syncpoint");
+    }
+
+    hr = DependencyPlanPackage(pdwInsertSequence, pPackage, pPlan);
+    ExitOnFailure(hr, "Failed to plan package dependency actions.");
+
+    // add execute action
+    if (BOOTSTRAPPER_ACTION_STATE_NONE != pPackage->execute)
+    {
+        if (NULL != pdwInsertSequence)
+        {
+            hr = PlanInsertExecuteAction(*pdwInsertSequence, pPlan, &pAction);
+            ExitOnFailure(hr, "Failed to insert execute action.");
+        }
+        else
+        {
+            hr = PlanAppendExecuteAction(pPlan, &pAction);
+            ExitOnFailure(hr, "Failed to append execute action.");
+        }
+
+        pAction->type = BURN_EXECUTE_ACTION_TYPE_EXE_PACKAGE;
+        pAction->exePackage.pPackage = pPackage;
+        pAction->exePackage.fFireAndForget = (BOOTSTRAPPER_ACTION_UPDATE_REPLACE == pPlan->action);
+        pAction->exePackage.action = pPackage->execute;
+
+        if (pPackage->Exe.sczIgnoreDependencies)
+        {
+            hr = StrAllocString(&pAction->exePackage.sczIgnoreDependencies, pPackage->Exe.sczIgnoreDependencies, 0);
+            ExitOnFailure(hr, "Failed to allocate the list of dependencies to ignore.");
+        }
+
+        if (pPackage->Exe.sczAncestors)
+        {
+            hr = StrAllocString(&pAction->exePackage.sczAncestors, pPackage->Exe.sczAncestors, 0);
+            ExitOnFailure(hr, "Failed to allocate the list of ancestors.");
+        }
+
+        LoggingSetPackageVariable(pPackage, NULL, FALSE, pLog, pVariables, NULL); // ignore errors.
+    }
+
+    // add rollback action
+    if (BOOTSTRAPPER_ACTION_STATE_NONE != pPackage->rollback)
+    {
+        hr = PlanAppendRollbackAction(pPlan, &pAction);
+        ExitOnFailure(hr, "Failed to append rollback action.");
+
+        pAction->type = BURN_EXECUTE_ACTION_TYPE_EXE_PACKAGE;
+        pAction->exePackage.pPackage = pPackage;
+        pAction->exePackage.action = pPackage->rollback;
+
+        if (pPackage->Exe.sczIgnoreDependencies)
+        {
+            hr = StrAllocString(&pAction->exePackage.sczIgnoreDependencies, pPackage->Exe.sczIgnoreDependencies, 0);
+            ExitOnFailure(hr, "Failed to allocate the list of dependencies to ignore.");
+        }
+
+        if (pPackage->Exe.sczAncestors)
+        {
+            hr = StrAllocString(&pAction->exePackage.sczAncestors, pPackage->Exe.sczAncestors, 0);
+            ExitOnFailure(hr, "Failed to allocate the list of ancestors.");
+        }
+
+        LoggingSetPackageVariable(pPackage, NULL, TRUE, pLog, pVariables, NULL); // ignore errors.
+    }
+
+LExit:
+    return hr;
+}
+
+extern "C" HRESULT ExeEngineExecutePackage(
+    __in BURN_EXECUTE_ACTION* pExecuteAction,
+    __in BURN_VARIABLES* pVariables,
+    __in BOOL fRollback,
+    __in PFN_GENERICMESSAGEHANDLER pfnGenericMessageHandler,
+    __in LPVOID pvContext,
+    __out BOOTSTRAPPER_APPLY_RESTART* pRestart
+    )
+{
+    HRESULT hr = S_OK;
+    WCHAR wzCurrentDirectory[MAX_PATH] = { };
+    BOOL fChangedCurrentDirectory = FALSE;
+    int nResult = IDNOACTION;
+    LPCWSTR wzArguments = NULL;
+    LPWSTR sczArguments = NULL;
+    LPWSTR sczArgumentsFormatted = NULL;
+    LPWSTR sczArgumentsObfuscated = NULL;
+    LPWSTR sczCachedDirectory = NULL;
+    LPWSTR sczExecutablePath = NULL;
+    LPWSTR sczCommand = NULL;
+    LPWSTR sczCommandObfuscated = NULL;
+    HANDLE hExecutableFile = INVALID_HANDLE_VALUE;
+    STARTUPINFOW si = { };
+    PROCESS_INFORMATION pi = { };
+    DWORD dwExitCode = 0;
+    GENERIC_EXECUTE_MESSAGE message = { };
+
+    // get cached executable path
+    hr = CacheGetCompletedPath(pExecuteAction->exePackage.pPackage->fPerMachine, pExecuteAction->exePackage.pPackage->sczCacheId, &sczCachedDirectory);
+    ExitOnFailure(hr, "Failed to get cached path for package: %ls", pExecuteAction->exePackage.pPackage->sczId);
+
+    // Best effort to set the execute package cache folder and action variables.
+    VariableSetString(pVariables, BURN_BUNDLE_EXECUTE_PACKAGE_CACHE_FOLDER, sczCachedDirectory, TRUE);
+    VariableSetNumeric(pVariables, BURN_BUNDLE_EXECUTE_PACKAGE_ACTION, pExecuteAction->exePackage.action, TRUE);
+
+    hr = PathConcat(sczCachedDirectory, pExecuteAction->exePackage.pPackage->rgPayloads[0].pPayload->sczFilePath, &sczExecutablePath);
+    ExitOnFailure(hr, "Failed to build executable path.");
+
+    // pick arguments
+    switch (pExecuteAction->exePackage.action)
+    {
+    case BOOTSTRAPPER_ACTION_STATE_INSTALL:
+        wzArguments = pExecuteAction->exePackage.pPackage->Exe.sczInstallArguments;
+        break;
+
+    case BOOTSTRAPPER_ACTION_STATE_UNINSTALL:
+        wzArguments = pExecuteAction->exePackage.pPackage->Exe.sczUninstallArguments;
+        break;
+
+    case BOOTSTRAPPER_ACTION_STATE_REPAIR:
+        wzArguments = pExecuteAction->exePackage.pPackage->Exe.sczRepairArguments;
+        break;
+
+    default:
+        hr = E_INVALIDARG;
+        ExitOnFailure(hr, "Invalid Exe package action: %d.", pExecuteAction->exePackage.action);
+    }
+
+    // now add optional arguments
+    hr = StrAllocString(&sczArguments, wzArguments && *wzArguments ? wzArguments : L"", 0);
+    ExitOnFailure(hr, "Failed to copy package arguments.");
+
+    for (DWORD i = 0; i < pExecuteAction->exePackage.pPackage->Exe.cCommandLineArguments; ++i)
+    {
+        BURN_EXE_COMMAND_LINE_ARGUMENT* commandLineArgument = &pExecuteAction->exePackage.pPackage->Exe.rgCommandLineArguments[i];
+        BOOL fCondition = FALSE;
+
+        hr = ConditionEvaluate(pVariables, commandLineArgument->sczCondition, &fCondition);
+        ExitOnFailure(hr, "Failed to evaluate executable package command-line condition.");
+
+        if (fCondition)
+        {
+            hr = StrAllocConcat(&sczArguments, L" ", 0);
+            ExitOnFailure(hr, "Failed to separate command-line arguments.");
+
+            switch (pExecuteAction->exePackage.action)
+            {
+            case BOOTSTRAPPER_ACTION_STATE_INSTALL:
+                hr = StrAllocConcat(&sczArguments, commandLineArgument->sczInstallArgument, 0);
+                ExitOnFailure(hr, "Failed to get command-line argument for install.");
+                break;
+
+            case BOOTSTRAPPER_ACTION_STATE_UNINSTALL:
+                hr = StrAllocConcat(&sczArguments, commandLineArgument->sczUninstallArgument, 0);
+                ExitOnFailure(hr, "Failed to get command-line argument for uninstall.");
+                break;
+
+            case BOOTSTRAPPER_ACTION_STATE_REPAIR:
+                hr = StrAllocConcat(&sczArguments, commandLineArgument->sczRepairArgument, 0);
+                ExitOnFailure(hr, "Failed to get command-line argument for repair.");
+                break;
+
+            default:
+                hr = E_INVALIDARG;
+                ExitOnFailure(hr, "Invalid Exe package action: %d.", pExecuteAction->exePackage.action);
+            }
+        }
+    }
+
+    // build command
+    if (0 < lstrlenW(sczArguments))
+    {
+        hr = VariableFormatString(pVariables, sczArguments, &sczArgumentsFormatted, NULL);
+        ExitOnFailure(hr, "Failed to format argument string.");
+
+        hr = StrAllocFormattedSecure(&sczCommand, L"\"%ls\" %s", sczExecutablePath, sczArgumentsFormatted);
+        ExitOnFailure(hr, "Failed to create executable command.");
+
+        hr = VariableFormatStringObfuscated(pVariables, sczArguments, &sczArgumentsObfuscated, NULL);
+        ExitOnFailure(hr, "Failed to format obfuscated argument string.");
+
+        hr = StrAllocFormatted(&sczCommandObfuscated, L"\"%ls\" %s", sczExecutablePath, sczArgumentsObfuscated);
+    }
+    else
+    {
+        hr = StrAllocFormatted(&sczCommand, L"\"%ls\"", sczExecutablePath);
+        ExitOnFailure(hr, "Failed to create executable command.");
+
+        hr = StrAllocFormatted(&sczCommandObfuscated, L"\"%ls\"", sczExecutablePath);
+    }
+    ExitOnFailure(hr, "Failed to create obfuscated executable command.");
+
+    if (pExecuteAction->exePackage.pPackage->Exe.fSupportsAncestors)
+    {
+        // Add the list of dependencies to ignore, if any, to the burn command line.
+        if (pExecuteAction->exePackage.sczIgnoreDependencies && BURN_EXE_PROTOCOL_TYPE_BURN == pExecuteAction->exePackage.pPackage->Exe.protocol)
+        {
+            hr = StrAllocFormattedSecure(&sczCommand, L"%ls -%ls=%ls", sczCommand, BURN_COMMANDLINE_SWITCH_IGNOREDEPENDENCIES, pExecuteAction->exePackage.sczIgnoreDependencies);
+            ExitOnFailure(hr, "Failed to append the list of dependencies to ignore to the command line.");
+
+            hr = StrAllocFormatted(&sczCommandObfuscated, L"%ls -%ls=%ls", sczCommandObfuscated, BURN_COMMANDLINE_SWITCH_IGNOREDEPENDENCIES, pExecuteAction->exePackage.sczIgnoreDependencies);
+            ExitOnFailure(hr, "Failed to append the list of dependencies to ignore to the obfuscated command line.");
+        }
+
+        // Add the list of ancestors, if any, to the burn command line.
+        if (pExecuteAction->exePackage.sczAncestors)
+        {
+            hr = StrAllocFormattedSecure(&sczCommand, L"%ls -%ls=%ls", sczCommand, BURN_COMMANDLINE_SWITCH_ANCESTORS, pExecuteAction->exePackage.sczAncestors);
+            ExitOnFailure(hr, "Failed to append the list of ancestors to the command line.");
+
+            hr = StrAllocFormatted(&sczCommandObfuscated, L"%ls -%ls=%ls", sczCommandObfuscated, BURN_COMMANDLINE_SWITCH_ANCESTORS, pExecuteAction->exePackage.sczAncestors);
+            ExitOnFailure(hr, "Failed to append the list of ancestors to the obfuscated command line.");
+        }
+    }
+
+    if (BURN_EXE_PROTOCOL_TYPE_BURN == pExecuteAction->exePackage.pPackage->Exe.protocol)
+    {
+        hr = CoreAppendFileHandleSelfToCommandLine(sczExecutablePath, &hExecutableFile, &sczCommand, &sczCommandObfuscated);
+        ExitOnFailure(hr, "Failed to append %ls", BURN_COMMANDLINE_SWITCH_FILEHANDLE_SELF);
+    }
+
+    // Log before we add the secret pipe name and client token for embedded processes.
+    LogId(REPORT_STANDARD, MSG_APPLYING_PACKAGE, LoggingRollbackOrExecute(fRollback), pExecuteAction->exePackage.pPackage->sczId, LoggingActionStateToString(pExecuteAction->exePackage.action), sczExecutablePath, sczCommandObfuscated);
+
+    if (!pExecuteAction->exePackage.fFireAndForget && BURN_EXE_PROTOCOL_TYPE_BURN == pExecuteAction->exePackage.pPackage->Exe.protocol)
+    {
+        hr = EmbeddedRunBundle(sczExecutablePath, sczCommand, pfnGenericMessageHandler, pvContext, &dwExitCode);
+        ExitOnFailure(hr, "Failed to run bundle as embedded from path: %ls", sczExecutablePath);
+    }
+    else if (!pExecuteAction->exePackage.fFireAndForget && BURN_EXE_PROTOCOL_TYPE_NETFX4 == pExecuteAction->exePackage.pPackage->Exe.protocol)
+    {
+        hr = NetFxRunChainer(sczExecutablePath, sczCommand, pfnGenericMessageHandler, pvContext, &dwExitCode);
+        ExitOnFailure(hr, "Failed to run netfx chainer: %ls", sczExecutablePath);
+    }
+    else // create and wait for the executable process while sending fake progress to allow cancel.
+    {
+        // Make the cache location of the executable the current directory to help those executables
+        // that expect stuff to be relative to them.
+        if (::GetCurrentDirectoryW(countof(wzCurrentDirectory), wzCurrentDirectory))
+        {
+            fChangedCurrentDirectory = ::SetCurrentDirectoryW(sczCachedDirectory);
+        }
+
+        si.cb = sizeof(si); // TODO: hookup the stdin/stdout/stderr pipes for logging purposes?
+        if (!::CreateProcessW(sczExecutablePath, sczCommand, NULL, NULL, TRUE, CREATE_NO_WINDOW, NULL, NULL, &si, &pi))
+        {
+            ExitWithLastError(hr, "Failed to CreateProcess on path: %ls", sczExecutablePath);
+        }
+
+        if (pExecuteAction->exePackage.fFireAndForget)
+        {
+            ::WaitForInputIdle(pi.hProcess, 5000);
+            ExitFunction();
+        }
+
+        do
+        {
+            message.type = GENERIC_EXECUTE_MESSAGE_PROGRESS;
+            message.dwAllowedResults = MB_OKCANCEL;
+            message.progress.dwPercentage = 50;
+            nResult = pfnGenericMessageHandler(&message, pvContext);
+            hr = (IDOK == nResult || IDNOACTION == nResult) ? S_OK : IDCANCEL == nResult ? HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT) : HRESULT_FROM_WIN32(ERROR_INSTALL_FAILURE);
+            ExitOnRootFailure(hr, "Bootstrapper application aborted during EXE progress.");
+
+            hr = ProcWaitForCompletion(pi.hProcess, 500, &dwExitCode);
+            if (HRESULT_FROM_WIN32(WAIT_TIMEOUT) != hr)
+            {
+                ExitOnFailure(hr, "Failed to wait for executable to complete: %ls", sczExecutablePath);
+            }
+        } while (HRESULT_FROM_WIN32(WAIT_TIMEOUT) == hr);
+    }
+
+    hr = HandleExitCode(pExecuteAction->exePackage.pPackage, dwExitCode, pRestart);
+    ExitOnRootFailure(hr, "Process returned error: 0x%x", dwExitCode);
+
+LExit:
+    if (fChangedCurrentDirectory)
+    {
+        ::SetCurrentDirectoryW(wzCurrentDirectory);
+    }
+
+    StrSecureZeroFreeString(sczArguments);
+    StrSecureZeroFreeString(sczArgumentsFormatted);
+    ReleaseStr(sczArgumentsObfuscated);
+    ReleaseStr(sczCachedDirectory);
+    ReleaseStr(sczExecutablePath);
+    StrSecureZeroFreeString(sczCommand);
+    ReleaseStr(sczCommandObfuscated);
+
+    ReleaseHandle(pi.hThread);
+    ReleaseHandle(pi.hProcess);
+    ReleaseFileHandle(hExecutableFile);
+
+    // Best effort to clear the execute package cache folder and action variables.
+    VariableSetString(pVariables, BURN_BUNDLE_EXECUTE_PACKAGE_CACHE_FOLDER, NULL, TRUE);
+    VariableSetString(pVariables, BURN_BUNDLE_EXECUTE_PACKAGE_ACTION, NULL, TRUE);
+
+    return hr;
+}
+
+
+// internal helper functions
+
+static HRESULT ParseExitCodesFromXml(
+    __in IXMLDOMNode* pixnExePackage,
+    __in BURN_PACKAGE* pPackage
+    )
+{
+    HRESULT hr = S_OK;
+    IXMLDOMNodeList* pixnNodes = NULL;
+    IXMLDOMNode* pixnNode = NULL;
+    DWORD cNodes = 0;
+    LPWSTR scz = NULL;
+
+    // select exit code nodes
+    hr = XmlSelectNodes(pixnExePackage, L"ExitCode", &pixnNodes);
+    ExitOnFailure(hr, "Failed to select exit code nodes.");
+
+    // get exit code node count
+    hr = pixnNodes->get_length((long*) &cNodes);
+    ExitOnFailure(hr, "Failed to get exit code node count.");
+
+    if (cNodes)
+    {
+        // allocate memory for exit codes
+        pPackage->Exe.rgExitCodes = (BURN_EXE_EXIT_CODE*) MemAlloc(sizeof(BURN_EXE_EXIT_CODE) * cNodes, TRUE);
+        ExitOnNull(pPackage->Exe.rgExitCodes, hr, E_OUTOFMEMORY, "Failed to allocate memory for exit code structs.");
+
+        pPackage->Exe.cExitCodes = cNodes;
+
+        // parse package elements
+        for (DWORD i = 0; i < cNodes; ++i)
+        {
+            BURN_EXE_EXIT_CODE* pExitCode = &pPackage->Exe.rgExitCodes[i];
+
+            hr = XmlNextElement(pixnNodes, &pixnNode, NULL);
+            ExitOnFailure(hr, "Failed to get next node.");
+
+            // @Type
+            hr = XmlGetAttributeNumber(pixnNode, L"Type", (DWORD*)&pExitCode->type);
+            ExitOnFailure(hr, "Failed to get @Type.");
+
+            // @Code
+            hr = XmlGetAttributeEx(pixnNode, L"Code", &scz);
+            ExitOnFailure(hr, "Failed to get @Code.");
+
+            if (L'*' == scz[0])
+            {
+                pExitCode->fWildcard = TRUE;
+            }
+            else
+            {
+                hr = StrStringToUInt32(scz, 0, (UINT*) &pExitCode->dwCode);
+                ExitOnFailure(hr, "Failed to parse @Code value: %ls", scz);
+            }
+
+            // prepare next iteration
+            ReleaseNullObject(pixnNode);
+        }
+    }
+
+    hr = S_OK;
+
+LExit:
+    ReleaseObject(pixnNodes);
+    ReleaseObject(pixnNode);
+    ReleaseStr(scz);
+
+    return hr;
+}
+
+static HRESULT ParseCommandLineArgumentsFromXml(
+    __in IXMLDOMNode* pixnExePackage,
+    __in BURN_PACKAGE* pPackage
+    )
+{
+    HRESULT hr = S_OK;
+    IXMLDOMNodeList* pixnNodes = NULL;
+    IXMLDOMNode* pixnNode = NULL;
+    DWORD cNodes = 0;
+    LPWSTR scz = NULL;
+
+    // Select command-line argument nodes.
+    hr = XmlSelectNodes(pixnExePackage, L"CommandLine", &pixnNodes);
+    ExitOnFailure(hr, "Failed to select command-line argument nodes.");
+
+    // Get command-line argument node count.
+    hr = pixnNodes->get_length((long*) &cNodes);
+    ExitOnFailure(hr, "Failed to get command-line argument count.");
+
+    if (cNodes)
+    {
+        pPackage->Exe.rgCommandLineArguments = (BURN_EXE_COMMAND_LINE_ARGUMENT*) MemAlloc(sizeof(BURN_EXE_COMMAND_LINE_ARGUMENT) * cNodes, TRUE);
+        ExitOnNull(pPackage->Exe.rgCommandLineArguments, hr, E_OUTOFMEMORY, "Failed to allocate memory for command-line argument structs.");
+
+        pPackage->Exe.cCommandLineArguments = cNodes;
+
+        // Parse command-line argument elements.
+        for (DWORD i = 0; i < cNodes; ++i)
+        {
+            BURN_EXE_COMMAND_LINE_ARGUMENT* pCommandLineArgument = &pPackage->Exe.rgCommandLineArguments[i];
+
+            hr = XmlNextElement(pixnNodes, &pixnNode, NULL);
+            ExitOnFailure(hr, "Failed to get next command-line argument node.");
+
+            // @InstallArgument
+            hr = XmlGetAttributeEx(pixnNode, L"InstallArgument", &pCommandLineArgument->sczInstallArgument);
+            ExitOnFailure(hr, "Failed to get @InstallArgument.");
+
+            // @UninstallArgument
+            hr = XmlGetAttributeEx(pixnNode, L"UninstallArgument", &pCommandLineArgument->sczUninstallArgument);
+            ExitOnFailure(hr, "Failed to get @UninstallArgument.");
+
+            // @RepairArgument
+            hr = XmlGetAttributeEx(pixnNode, L"RepairArgument", &pCommandLineArgument->sczRepairArgument);
+            ExitOnFailure(hr, "Failed to get @RepairArgument.");
+
+            // @Condition
+            hr = XmlGetAttributeEx(pixnNode, L"Condition", &pCommandLineArgument->sczCondition);
+            ExitOnFailure(hr, "Failed to get @Condition.");
+
+            // Prepare next iteration.
+            ReleaseNullObject(pixnNode);
+        }
+    }
+
+    hr = S_OK;
+
+LExit:
+    ReleaseObject(pixnNodes);
+    ReleaseObject(pixnNode);
+    ReleaseStr(scz);
+
+    return hr;
+}
+
+static HRESULT HandleExitCode(
+    __in BURN_PACKAGE* pPackage,
+    __in DWORD dwExitCode,
+    __out BOOTSTRAPPER_APPLY_RESTART* pRestart
+    )
+{
+    HRESULT hr = S_OK;
+    BURN_EXE_EXIT_CODE_TYPE typeCode = BURN_EXE_EXIT_CODE_TYPE_NONE;
+
+    for (DWORD i = 0; i < pPackage->Exe.cExitCodes; ++i)
+    {
+        BURN_EXE_EXIT_CODE* pExitCode = &pPackage->Exe.rgExitCodes[i];
+
+        // If this is a wildcard, use the last one we come across.
+        if (pExitCode->fWildcard)
+        {
+            typeCode = pExitCode->type;
+        }
+        else if (dwExitCode == pExitCode->dwCode) // If we have an exact match on the error code use that and stop looking.
+        {
+            typeCode = pExitCode->type;
+            break;
+        }
+    }
+
+    // If we didn't find a matching code then treat 0 as success, the standard restarts codes as restarts
+    // and everything else as an error.
+    if (BURN_EXE_EXIT_CODE_TYPE_NONE == typeCode)
+    {
+        if (0 == dwExitCode)
+        {
+            typeCode = BURN_EXE_EXIT_CODE_TYPE_SUCCESS;
+        }
+        else if (ERROR_SUCCESS_REBOOT_REQUIRED == dwExitCode ||
+                 HRESULT_FROM_WIN32(ERROR_SUCCESS_REBOOT_REQUIRED) == static_cast<HRESULT>(dwExitCode) ||
+                 ERROR_SUCCESS_RESTART_REQUIRED == dwExitCode ||
+                 HRESULT_FROM_WIN32(ERROR_SUCCESS_RESTART_REQUIRED) == static_cast<HRESULT>(dwExitCode))
+        {
+            typeCode = BURN_EXE_EXIT_CODE_TYPE_SCHEDULE_REBOOT;
+        }
+        else if (ERROR_SUCCESS_REBOOT_INITIATED == dwExitCode ||
+                 HRESULT_FROM_WIN32(ERROR_SUCCESS_REBOOT_INITIATED) == static_cast<HRESULT>(dwExitCode))
+        {
+            typeCode = BURN_EXE_EXIT_CODE_TYPE_FORCE_REBOOT;
+        }
+        else
+        {
+            typeCode = BURN_EXE_EXIT_CODE_TYPE_ERROR;
+        }
+    }
+
+    switch (typeCode)
+    {
+    case BURN_EXE_EXIT_CODE_TYPE_SUCCESS:
+        *pRestart = BOOTSTRAPPER_APPLY_RESTART_NONE;
+        hr = S_OK;
+        break;
+
+    case BURN_EXE_EXIT_CODE_TYPE_ERROR:
+        *pRestart = BOOTSTRAPPER_APPLY_RESTART_NONE;
+        hr = HRESULT_FROM_WIN32(dwExitCode);
+        if (SUCCEEDED(hr))
+        {
+            hr = E_FAIL;
+        }
+        break;
+
+    case BURN_EXE_EXIT_CODE_TYPE_SCHEDULE_REBOOT:
+        *pRestart = BOOTSTRAPPER_APPLY_RESTART_REQUIRED;
+        hr = S_OK;
+        break;
+
+    case BURN_EXE_EXIT_CODE_TYPE_FORCE_REBOOT:
+        *pRestart = BOOTSTRAPPER_APPLY_RESTART_INITIATED;
+        hr = S_OK;
+        break;
+
+    default:
+        hr = E_UNEXPECTED;
+        break;
+    }
+
+//LExit:
+    return hr;
+}
diff --git a/src/engine/exeengine.h b/src/engine/exeengine.h
new file mode 100644
index 00000000..402e51ed
--- /dev/null
+++ b/src/engine/exeengine.h
@@ -0,0 +1,48 @@
+#pragma once
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+
+// function declarations
+
+HRESULT ExeEngineParsePackageFromXml(
+    __in IXMLDOMNode* pixnExePackage,
+    __in BURN_PACKAGE* pPackage
+    );
+void ExeEnginePackageUninitialize(
+    __in BURN_PACKAGE* pPackage
+    );
+HRESULT ExeEngineDetectPackage(
+    __in BURN_PACKAGE* pPackage,
+    __in BURN_VARIABLES* pVariables
+    );
+HRESULT ExeEnginePlanCalculatePackage(
+    __in BURN_PACKAGE* pPackage,
+    __out_opt BOOL* pfBARequestedCache
+    );
+HRESULT ExeEnginePlanAddPackage(
+    __in_opt DWORD *pdwInsertSequence,
+    __in BURN_PACKAGE* pPackage,
+    __in BURN_PLAN* pPlan,
+    __in BURN_LOGGING* pLog,
+    __in BURN_VARIABLES* pVariables,
+    __in_opt HANDLE hCacheEvent,
+    __in BOOL fPlanPackageCacheRollback
+    );
+HRESULT ExeEngineExecutePackage(
+    __in BURN_EXECUTE_ACTION* pExecuteAction,
+    __in BURN_VARIABLES* pVariables,
+    __in BOOL fRollback,
+    __in PFN_GENERICMESSAGEHANDLER pfnGenericExecuteProgress,
+    __in LPVOID pvContext,
+    __out BOOTSTRAPPER_APPLY_RESTART* pRestart
+    );
+
+
+#if defined(__cplusplus)
+}
+#endif
diff --git a/src/engine/inc/engine.h b/src/engine/inc/engine.h
new file mode 100644
index 00000000..808bb91a
--- /dev/null
+++ b/src/engine/inc/engine.h
@@ -0,0 +1,27 @@
+#pragma once
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+
+// function declarations
+
+BOOL EngineInCleanRoom(
+    __in_z_opt LPCWSTR wzCommandLine
+    );
+
+HRESULT EngineRun(
+    __in HINSTANCE hInstance,
+    __in HANDLE hEngineFile,
+    __in_z_opt LPCWSTR wzCommandLine,
+    __in int nCmdShow,
+    __out DWORD* pdwExitCode
+    );
+
+
+#if defined(__cplusplus)
+}
+#endif
diff --git a/src/engine/logging.cpp b/src/engine/logging.cpp
new file mode 100644
index 00000000..818532ad
--- /dev/null
+++ b/src/engine/logging.cpp
@@ -0,0 +1,683 @@
+// 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.
+
+#include "precomp.h"
+
+
+static DWORD vdwPackageSequence = 0;
+static const DWORD LOG_OPEN_RETRY_COUNT = 3;
+static const DWORD LOG_OPEN_RETRY_WAIT = 2000;
+static CONST LPWSTR LOG_FAILED_EVENT_LOG_MESSAGE = L"Burn Engine Fatal Error: failed to open log file.";
+
+// structs
+
+
+
+// internal function declarations
+
+static void CheckLoggingPolicy(
+    __out DWORD *pdwAttributes
+    );
+static HRESULT GetNonSessionSpecificTempFolder(
+    __deref_out_z LPWSTR* psczNonSessionTempFolder
+    );
+
+
+// function definitions
+
+extern "C" HRESULT LoggingOpen(
+    __in BURN_LOGGING* pLog,
+    __in BURN_VARIABLES* pVariables,
+    __in BOOTSTRAPPER_DISPLAY display,
+    __in_z LPCWSTR wzBundleName
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR sczLoggingBaseFolder = NULL;
+
+    // Check if the logging policy is set and configure the logging appropriately.
+    CheckLoggingPolicy(&pLog->dwAttributes);
+
+    if (pLog->dwAttributes & BURN_LOGGING_ATTRIBUTE_VERBOSE || pLog->dwAttributes & BURN_LOGGING_ATTRIBUTE_EXTRADEBUG)
+    {
+        if (pLog->dwAttributes & BURN_LOGGING_ATTRIBUTE_EXTRADEBUG)
+        {
+            LogSetLevel(REPORT_DEBUG, FALSE);
+        }
+        else if (pLog->dwAttributes & BURN_LOGGING_ATTRIBUTE_VERBOSE)
+        {
+            LogSetLevel(REPORT_VERBOSE, FALSE);
+        }
+
+        if ((!pLog->sczPath || !*pLog->sczPath) && (!pLog->sczPrefix || !*pLog->sczPrefix))
+        {
+            PathCreateTimeBasedTempFile(NULL, L"Setup", NULL, L"log", &pLog->sczPath, NULL);
+        }
+    }
+
+    // Open the log approriately.
+    if (pLog->sczPath && *pLog->sczPath)
+    {
+        DWORD cRetry = 0;
+
+        hr = DirGetCurrent(&sczLoggingBaseFolder);
+        ExitOnFailure(hr, "Failed to get current directory.");
+
+        // Try pretty hard to open the log file when appending.
+        do
+        {
+            if (0 < cRetry)
+            {
+                ::Sleep(LOG_OPEN_RETRY_WAIT);
+            }
+
+            hr = LogOpen(sczLoggingBaseFolder, pLog->sczPath, NULL, NULL, pLog->dwAttributes & BURN_LOGGING_ATTRIBUTE_APPEND, FALSE, &pLog->sczPath);
+            if (pLog->dwAttributes & BURN_LOGGING_ATTRIBUTE_APPEND && HRESULT_FROM_WIN32(ERROR_SHARING_VIOLATION) == hr)
+            {
+                ++cRetry;
+            }
+        } while (cRetry > 0 && cRetry <= LOG_OPEN_RETRY_COUNT);
+
+        if (FAILED(hr))
+        {
+            // Log is not open, so note that.
+            LogDisable();
+            pLog->state = BURN_LOGGING_STATE_DISABLED;
+
+            if (pLog->dwAttributes & BURN_LOGGING_ATTRIBUTE_APPEND)
+            {
+                // If appending, ignore the failure and continue.
+                hr = S_OK;
+            }
+            else // specifically tried to create a log file so show an error if appropriate and bail.
+            {
+                HRESULT hrOriginal = hr;
+
+                hr = HRESULT_FROM_WIN32(ERROR_INSTALL_LOG_FAILURE);
+                SplashScreenDisplayError(display, wzBundleName, hr);
+
+                ExitOnFailure(hrOriginal, "Failed to open log: %ls", pLog->sczPath);
+            }
+        }
+        else
+        {
+            pLog->state = BURN_LOGGING_STATE_OPEN;
+        }
+    }
+    else if (pLog->sczPrefix && *pLog->sczPrefix)
+    {
+        hr = GetNonSessionSpecificTempFolder(&sczLoggingBaseFolder);
+        ExitOnFailure(hr, "Failed to get non-session specific TEMP folder.");
+
+        // Best effort to open default logging.
+        hr = LogOpen(sczLoggingBaseFolder, pLog->sczPrefix, NULL, pLog->sczExtension, FALSE, FALSE, &pLog->sczPath);
+        if (FAILED(hr))
+        {
+            LogDisable();
+            pLog->state = BURN_LOGGING_STATE_DISABLED;
+
+            hr = S_OK;
+        }
+        else
+        {
+            pLog->state = BURN_LOGGING_STATE_OPEN;
+        }
+    }
+    else // no logging enabled.
+    {
+        LogDisable();
+        pLog->state = BURN_LOGGING_STATE_DISABLED;
+    }
+
+    // If the log was opened, write the header info and update the prefix and extension to match
+    // the log name so future logs are opened with the same pattern.
+    if (BURN_LOGGING_STATE_OPEN == pLog->state)
+    {
+        LPCWSTR wzExtension = PathExtension(pLog->sczPath);
+        if (wzExtension && *wzExtension)
+        {
+            hr = StrAllocString(&pLog->sczPrefix, pLog->sczPath, wzExtension - pLog->sczPath);
+            ExitOnFailure(hr, "Failed to copy log path to prefix.");
+
+            hr = StrAllocString(&pLog->sczExtension, wzExtension + 1, 0);
+            ExitOnFailure(hr, "Failed to copy log extension to extension.");
+        }
+        else
+        {
+            hr = StrAllocString(&pLog->sczPrefix, pLog->sczPath, 0);
+            ExitOnFailure(hr, "Failed to copy full log path to prefix.");
+        }
+
+        if (pLog->sczPathVariable && *pLog->sczPathVariable)
+        {
+            VariableSetString(pVariables, pLog->sczPathVariable, pLog->sczPath, FALSE); // Ignore failure.
+        }
+    }
+
+LExit:
+    ReleaseStr(sczLoggingBaseFolder);
+
+    return hr;
+}
+
+extern "C" void LoggingOpenFailed()
+{
+    HRESULT hr = S_OK;
+    HANDLE hEventLog = NULL;
+    LPCWSTR* lpStrings = const_cast<LPCWSTR*>(&LOG_FAILED_EVENT_LOG_MESSAGE);
+    WORD wNumStrings = 1;
+
+    hr = LogOpen(NULL, L"Setup", L"_Failed", L"txt", FALSE, FALSE, NULL);
+    if (SUCCEEDED(hr))
+    {
+        ExitFunction();
+    }
+
+    // If opening the "failure" log failed, then attempt to record that in the Application event log.
+    hEventLog = ::OpenEventLogW(NULL, L"Application");
+    ExitOnNullWithLastError(hEventLog, hr, "Failed to open Application event log");
+
+    hr = ::ReportEventW(hEventLog, EVENTLOG_ERROR_TYPE, 1, 1, NULL, wNumStrings, 0, lpStrings, NULL);
+    ExitOnNullWithLastError(hEventLog, hr, "Failed to write event log entry");
+
+LExit:
+    if (hEventLog)
+    {
+        ::CloseEventLog(hEventLog);
+    }
+}
+
+extern "C" void LoggingIncrementPackageSequence()
+{
+    ++vdwPackageSequence;
+}
+
+extern "C" HRESULT LoggingSetPackageVariable(
+    __in BURN_PACKAGE* pPackage,
+    __in_z_opt LPCWSTR wzSuffix,
+    __in BOOL fRollback,
+    __in BURN_LOGGING* pLog,
+    __in BURN_VARIABLES* pVariables,
+    __out_opt LPWSTR* psczLogPath
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR sczLogPath = NULL;
+
+    // Make sure that no package log files are created when logging has been disabled via Log element.
+    if (BURN_LOGGING_STATE_DISABLED == pLog->state)
+    {
+        if (psczLogPath)
+        {
+            *psczLogPath = NULL;
+        }
+
+        ExitFunction();
+    }
+
+    if ((!fRollback && pPackage->sczLogPathVariable && *pPackage->sczLogPathVariable) ||
+        (fRollback && pPackage->sczRollbackLogPathVariable && *pPackage->sczRollbackLogPathVariable))
+    {
+        hr = StrAllocFormatted(&sczLogPath, L"%ls%hs%ls_%03u_%ls%ls.%ls", pLog->sczPrefix, wzSuffix && *wzSuffix ? "_" : "", wzSuffix && *wzSuffix ? wzSuffix : L"", vdwPackageSequence, pPackage->sczId, fRollback ? L"_rollback" : L"", pLog->sczExtension);
+        ExitOnFailure(hr, "Failed to allocate path for package log.");
+
+        hr = VariableSetString(pVariables, fRollback ? pPackage->sczRollbackLogPathVariable : pPackage->sczLogPathVariable, sczLogPath, FALSE);
+        ExitOnFailure(hr, "Failed to set log path into variable.");
+
+        if (psczLogPath)
+        {
+            hr = StrAllocString(psczLogPath, sczLogPath, 0);
+            ExitOnFailure(hr, "Failed to copy package log path.");
+        }
+    }
+
+LExit:
+    ReleaseStr(sczLogPath);
+
+    return hr;
+}
+
+extern "C" LPCSTR LoggingBurnActionToString(
+    __in BOOTSTRAPPER_ACTION action
+    )
+{
+    switch (action)
+    {
+    case BOOTSTRAPPER_ACTION_UNKNOWN:
+        return "Unknown";
+    case BOOTSTRAPPER_ACTION_HELP:
+        return "Help";
+    case BOOTSTRAPPER_ACTION_LAYOUT:
+        return "Layout";
+    case BOOTSTRAPPER_ACTION_CACHE:
+        return "Cache";
+    case BOOTSTRAPPER_ACTION_UNINSTALL:
+        return "Uninstall";
+    case BOOTSTRAPPER_ACTION_INSTALL:
+        return "Install";
+    case BOOTSTRAPPER_ACTION_MODIFY:
+        return "Modify";
+    case BOOTSTRAPPER_ACTION_REPAIR:
+        return "Repair";
+    case BOOTSTRAPPER_ACTION_UPDATE_REPLACE:
+        return "UpdateReplace";
+    case BOOTSTRAPPER_ACTION_UPDATE_REPLACE_EMBEDDED:
+        return "UpdateReplaceEmbedded";
+    default:
+        return "Invalid";
+    }
+}
+
+extern "C" LPCSTR LoggingActionStateToString(
+    __in BOOTSTRAPPER_ACTION_STATE actionState
+    )
+{
+    switch (actionState)
+    {
+    case BOOTSTRAPPER_ACTION_STATE_NONE:
+        return "None";
+    case BOOTSTRAPPER_ACTION_STATE_UNINSTALL:
+        return "Uninstall";
+    case BOOTSTRAPPER_ACTION_STATE_INSTALL:
+        return "Install";
+    case BOOTSTRAPPER_ACTION_STATE_ADMIN_INSTALL:
+        return "AdminInstall";
+    case BOOTSTRAPPER_ACTION_STATE_MODIFY:
+        return "Modify";
+    case BOOTSTRAPPER_ACTION_STATE_REPAIR:
+        return "Repair";
+    case BOOTSTRAPPER_ACTION_STATE_MINOR_UPGRADE:
+        return "MinorUpgrade";
+    case BOOTSTRAPPER_ACTION_STATE_MAJOR_UPGRADE:
+        return "MajorUpgrade";
+    case BOOTSTRAPPER_ACTION_STATE_PATCH:
+        return "Patch";
+    default:
+        return "Invalid";
+    }
+}
+
+extern "C" LPCSTR LoggingDependencyActionToString(
+    BURN_DEPENDENCY_ACTION action
+    )
+{
+    switch (action)
+    {
+    case BURN_DEPENDENCY_ACTION_NONE:
+        return "None";
+    case BURN_DEPENDENCY_ACTION_REGISTER:
+        return "Register";
+    case BURN_DEPENDENCY_ACTION_UNREGISTER:
+        return "Unregister";
+    default:
+        return "Invalid";
+    }
+}
+
+extern "C" LPCSTR LoggingBoolToString(
+    __in BOOL f
+    )
+{
+    if (f)
+    {
+        return "Yes";
+    }
+
+    return "No";
+}
+
+extern "C" LPCSTR LoggingTrueFalseToString(
+    __in BOOL f
+    )
+{
+    if (f)
+    {
+        return "true";
+    }
+
+    return "false";
+}
+
+extern "C" LPCSTR LoggingPackageStateToString(
+    __in BOOTSTRAPPER_PACKAGE_STATE packageState
+    )
+{
+    switch (packageState)
+    {
+    case BOOTSTRAPPER_PACKAGE_STATE_UNKNOWN:
+        return "Unknown";
+    case BOOTSTRAPPER_PACKAGE_STATE_OBSOLETE:
+        return "Obsolete";
+    case BOOTSTRAPPER_PACKAGE_STATE_ABSENT:
+        return "Absent";
+    case BOOTSTRAPPER_PACKAGE_STATE_CACHED:
+        return "Cached";
+    case BOOTSTRAPPER_PACKAGE_STATE_PRESENT:
+        return "Present";
+    case BOOTSTRAPPER_PACKAGE_STATE_SUPERSEDED:
+        return "Superseded";
+    default:
+        return "Invalid";
+    }
+}
+
+extern "C" LPCSTR LoggingCacheStateToString(
+    __in BURN_CACHE_STATE cacheState
+    )
+{
+    switch (cacheState)
+    {
+    case BURN_CACHE_STATE_NONE:
+        return "None";
+    case BURN_CACHE_STATE_PARTIAL:
+        return "Partial";
+    case BURN_CACHE_STATE_COMPLETE:
+        return "Complete";
+    default:
+        return "Invalid";
+    }
+}
+
+extern "C" LPCSTR LoggingMsiFeatureStateToString(
+    __in BOOTSTRAPPER_FEATURE_STATE featureState
+    )
+{
+    switch (featureState)
+    {
+    case BOOTSTRAPPER_FEATURE_STATE_UNKNOWN:
+        return "Unknown";
+    case BOOTSTRAPPER_FEATURE_STATE_ABSENT:
+        return "Absent";
+    case BOOTSTRAPPER_FEATURE_STATE_ADVERTISED:
+        return "Advertised";
+    case BOOTSTRAPPER_FEATURE_STATE_LOCAL:
+        return "Local";
+    case BOOTSTRAPPER_FEATURE_STATE_SOURCE:
+        return "Source";
+    default:
+        return "Invalid";
+    }
+}
+
+extern "C" LPCSTR LoggingMsiFeatureActionToString(
+    __in BOOTSTRAPPER_FEATURE_ACTION featureAction
+    )
+{
+    switch (featureAction)
+    {
+    case BOOTSTRAPPER_FEATURE_ACTION_NONE:
+        return "None";
+    case BOOTSTRAPPER_FEATURE_ACTION_ADDLOCAL:
+        return "AddLocal";
+    case BOOTSTRAPPER_FEATURE_ACTION_ADDSOURCE:
+        return "AddSource";
+    case BOOTSTRAPPER_FEATURE_ACTION_ADDDEFAULT:
+        return "AddDefault";
+    case BOOTSTRAPPER_FEATURE_ACTION_REINSTALL:
+        return "Reinstall";
+    case BOOTSTRAPPER_FEATURE_ACTION_ADVERTISE:
+        return "Advertise";
+    case BOOTSTRAPPER_FEATURE_ACTION_REMOVE:
+        return "Remove";
+    default:
+        return "Invalid";
+    }
+}
+
+extern "C" LPCSTR LoggingMsiInstallContext(
+    __in MSIINSTALLCONTEXT context
+    )
+{
+    switch (context)
+    {
+    case MSIINSTALLCONTEXT_ALL:
+        return "All";
+    case MSIINSTALLCONTEXT_ALLUSERMANAGED:
+        return "AllUserManaged";
+    case MSIINSTALLCONTEXT_MACHINE:
+        return "Machine";
+    case MSIINSTALLCONTEXT_NONE:
+        return "None";
+    case MSIINSTALLCONTEXT_USERMANAGED:
+        return "UserManaged";
+    case MSIINSTALLCONTEXT_USERUNMANAGED:
+        return "UserUnmanaged";
+    default:
+        return "Invalid";
+    }
+}
+
+extern "C" LPCSTR LoggingPerMachineToString(
+    __in BOOL fPerMachine
+    )
+{
+    if (fPerMachine)
+    {
+        return "PerMachine";
+    }
+
+    return "PerUser";
+}
+
+extern "C" LPCSTR LoggingRestartToString(
+    __in BOOTSTRAPPER_APPLY_RESTART restart
+    )
+{
+    switch (restart)
+    {
+    case BOOTSTRAPPER_APPLY_RESTART_NONE:
+        return "None";
+    case BOOTSTRAPPER_APPLY_RESTART_REQUIRED:
+        return "Required";
+    case BOOTSTRAPPER_APPLY_RESTART_INITIATED:
+        return "Initiated";
+    default:
+        return "Invalid";
+    }
+}
+
+extern "C" LPCSTR LoggingResumeModeToString(
+    __in BURN_RESUME_MODE resumeMode
+    )
+{
+    switch (resumeMode)
+    {
+    case BURN_RESUME_MODE_NONE:
+        return "None";
+    case BURN_RESUME_MODE_ACTIVE:
+        return "Active";
+    case BURN_RESUME_MODE_SUSPEND:
+        return "Suspend";
+    case BURN_RESUME_MODE_ARP:
+        return "ARP";
+    case BURN_RESUME_MODE_REBOOT_PENDING:
+        return "Reboot Pending";
+    default:
+        return "Invalid";
+    }
+}
+
+extern "C" LPCSTR LoggingRelationTypeToString(
+    __in BOOTSTRAPPER_RELATION_TYPE type
+    )
+{
+    switch (type)
+    {
+    case BOOTSTRAPPER_RELATION_NONE:
+        return "None";
+    case BOOTSTRAPPER_RELATION_DETECT:
+        return "Detect";
+    case BOOTSTRAPPER_RELATION_UPGRADE:
+        return "Upgrade";
+    case BOOTSTRAPPER_RELATION_ADDON:
+        return "Addon";
+    case BOOTSTRAPPER_RELATION_PATCH:
+        return "Patch";
+    case BOOTSTRAPPER_RELATION_DEPENDENT:
+        return "Dependent";
+    case BOOTSTRAPPER_RELATION_UPDATE:
+        return "Update";
+    default:
+        return "Invalid";
+    }
+}
+
+extern "C" LPCSTR LoggingRelatedOperationToString(
+    __in BOOTSTRAPPER_RELATED_OPERATION operation
+    )
+{
+    switch (operation)
+    {
+    case BOOTSTRAPPER_RELATED_OPERATION_NONE:
+        return "None";
+    case BOOTSTRAPPER_RELATED_OPERATION_DOWNGRADE:
+        return "Downgrade";
+    case BOOTSTRAPPER_RELATED_OPERATION_MINOR_UPDATE:
+        return "MinorUpdate";
+    case BOOTSTRAPPER_RELATED_OPERATION_MAJOR_UPGRADE:
+        return "MajorUpgrade";
+    case BOOTSTRAPPER_RELATED_OPERATION_REMOVE:
+        return "Remove";
+    case BOOTSTRAPPER_RELATED_OPERATION_INSTALL:
+        return "Install";
+    case BOOTSTRAPPER_RELATED_OPERATION_REPAIR:
+        return "Repair";
+    default:
+        return "Invalid";
+    }
+}
+
+extern "C" LPCSTR LoggingRequestStateToString(
+    __in BOOTSTRAPPER_REQUEST_STATE requestState
+    )
+{
+    switch (requestState)
+    {
+    case BOOTSTRAPPER_REQUEST_STATE_NONE:
+        return "None";
+    case BOOTSTRAPPER_REQUEST_STATE_FORCE_ABSENT:
+        return "ForceAbsent";
+    case BOOTSTRAPPER_REQUEST_STATE_ABSENT:
+        return "Absent";
+    case BOOTSTRAPPER_REQUEST_STATE_CACHE:
+        return "Cache";
+    case BOOTSTRAPPER_REQUEST_STATE_PRESENT:
+        return "Present";
+    case BOOTSTRAPPER_REQUEST_STATE_REPAIR:
+        return "Repair";
+    default:
+        return "Invalid";
+    }
+}
+
+extern "C" LPCSTR LoggingRollbackOrExecute(
+    __in BOOL fRollback
+    )
+{
+    return fRollback ? "rollback" : "execute";
+}
+
+extern "C" LPWSTR LoggingStringOrUnknownIfNull(
+    __in LPCWSTR wz
+    )
+{
+    return wz ? wz : L"Unknown";
+}
+
+// Note: this function is not thread safe.
+extern "C" LPCSTR LoggingVersionToString(
+    __in DWORD64 dw64Version
+    )
+{
+    static CHAR szVersion[40] = { 0 };
+    HRESULT hr = S_OK;
+
+    hr = ::StringCchPrintfA(szVersion, countof(szVersion), "%I64u.%I64u.%I64u.%I64u", dw64Version >> 48 & 0xFFFF, dw64Version >> 32 & 0xFFFF, dw64Version >> 16 & 0xFFFF, dw64Version  & 0xFFFF);
+    if (FAILED(hr))
+    {
+        memset(szVersion, 0, sizeof(szVersion));
+    }
+
+    return szVersion;
+}
+
+
+// internal function declarations
+
+static void CheckLoggingPolicy(
+    __out DWORD *pdwAttributes
+    )
+{
+    HRESULT hr = S_OK;
+    HKEY hk = NULL;
+    LPWSTR sczLoggingPolicy = NULL;
+
+    hr = RegOpen(HKEY_LOCAL_MACHINE, L"SOFTWARE\\Policies\\Microsoft\\Windows\\Installer", KEY_READ, &hk);
+    if (SUCCEEDED(hr))
+    {
+        hr = RegReadString(hk, L"Logging", &sczLoggingPolicy);
+        if (SUCCEEDED(hr))
+        {
+            LPCWSTR wz = sczLoggingPolicy;
+            while (*wz)
+            {
+                if (L'v' == *wz || L'V' == *wz)
+                {
+                    *pdwAttributes |= BURN_LOGGING_ATTRIBUTE_VERBOSE;
+                }
+                else if (L'x' == *wz || L'X' == *wz)
+                {
+                    *pdwAttributes |= BURN_LOGGING_ATTRIBUTE_EXTRADEBUG;
+                }
+
+                ++wz;
+            }
+        }
+    }
+
+    ReleaseStr(sczLoggingPolicy);
+    ReleaseRegKey(hk);
+}
+
+static HRESULT GetNonSessionSpecificTempFolder(
+    __deref_out_z LPWSTR* psczNonSessionTempFolder
+    )
+{
+    HRESULT hr = S_OK;
+    WCHAR wzTempFolder[MAX_PATH] = { };
+    DWORD cchTempFolder = 0;
+    DWORD dwSessionId = 0;
+    LPWSTR sczSessionId = 0;
+    DWORD cchSessionId = 0;
+
+    if (!::GetTempPathW(countof(wzTempFolder), wzTempFolder))
+    {
+        ExitWithLastError(hr, "Failed to get temp folder.");
+    }
+
+    hr = ::StringCchLengthW(wzTempFolder, countof(wzTempFolder), reinterpret_cast<size_t*>(&cchTempFolder));
+    ExitOnFailure(hr, "Failed to get length of temp folder.");
+
+    // If our session id is in the TEMP path then remove that part so we get the non-session
+    // specific temporary folder.
+    if (::ProcessIdToSessionId(::GetCurrentProcessId(), &dwSessionId))
+    {
+        hr = StrAllocFormatted(&sczSessionId, L"%u\\", dwSessionId);
+        ExitOnFailure(hr, "Failed to format session id as a string.");
+
+        hr = ::StringCchLengthW(sczSessionId, STRSAFE_MAX_CCH, reinterpret_cast<size_t*>(&cchSessionId));
+        ExitOnFailure(hr, "Failed to get length of session id string.");
+
+        if (CSTR_EQUAL == ::CompareStringW(LOCALE_NEUTRAL, 0, wzTempFolder + cchTempFolder - cchSessionId, cchSessionId, sczSessionId, cchSessionId))
+        {
+            cchTempFolder -= cchSessionId;
+        }
+    }
+
+    hr = StrAllocString(psczNonSessionTempFolder, wzTempFolder, cchTempFolder);
+    ExitOnFailure(hr, "Failed to copy temp folder.");
+
+LExit:
+    ReleaseStr(sczSessionId);
+
+    return hr;
+}
diff --git a/src/engine/logging.h b/src/engine/logging.h
new file mode 100644
index 00000000..cea4d31d
--- /dev/null
+++ b/src/engine/logging.h
@@ -0,0 +1,144 @@
+#pragma once
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+
+// constants
+
+enum BURN_LOGGING_STATE
+{
+    BURN_LOGGING_STATE_CLOSED,
+    BURN_LOGGING_STATE_OPEN,
+    BURN_LOGGING_STATE_DISABLED,
+};
+
+enum BURN_LOGGING_ATTRIBUTE
+{
+    BURN_LOGGING_ATTRIBUTE_APPEND = 0x1,
+    BURN_LOGGING_ATTRIBUTE_VERBOSE = 0x2,
+    BURN_LOGGING_ATTRIBUTE_EXTRADEBUG = 0x4,
+};
+
+
+// structs
+
+typedef struct _BURN_LOGGING
+{
+    BURN_LOGGING_STATE state;
+    LPWSTR sczPathVariable;
+
+    DWORD dwAttributes;
+    LPWSTR sczPath;
+    LPWSTR sczPrefix;
+    LPWSTR sczExtension;
+} BURN_LOGGING;
+
+
+
+// function declarations
+
+HRESULT LoggingOpen(
+    __in BURN_LOGGING* pLog,
+    __in BURN_VARIABLES* pVariables,
+    __in BOOTSTRAPPER_DISPLAY display,
+    __in_z LPCWSTR wzBundleName
+    );
+
+void LoggingOpenFailed();
+
+void LoggingIncrementPackageSequence();
+
+HRESULT LoggingSetPackageVariable(
+    __in BURN_PACKAGE* pPackage,
+    __in_z_opt LPCWSTR wzSuffix,
+    __in BOOL fRollback,
+    __in BURN_LOGGING* pLog,
+    __in BURN_VARIABLES* pVariables,
+    __out_opt LPWSTR* psczLogPath
+    );
+
+LPCSTR LoggingBurnActionToString(
+    __in BOOTSTRAPPER_ACTION action
+    );
+
+LPCSTR LoggingActionStateToString(
+    __in BOOTSTRAPPER_ACTION_STATE actionState
+    );
+
+LPCSTR LoggingDependencyActionToString(
+    BURN_DEPENDENCY_ACTION action
+    );
+
+LPCSTR LoggingBoolToString(
+    __in BOOL f
+    );
+
+LPCSTR LoggingTrueFalseToString(
+    __in BOOL f
+    );
+
+LPCSTR LoggingPackageStateToString(
+    __in BOOTSTRAPPER_PACKAGE_STATE packageState
+    );
+
+LPCSTR LoggingCacheStateToString(
+    __in BURN_CACHE_STATE cacheState
+    );
+
+LPCSTR LoggingMsiFeatureStateToString(
+    __in BOOTSTRAPPER_FEATURE_STATE featureState
+    );
+
+LPCSTR LoggingMsiFeatureActionToString(
+    __in BOOTSTRAPPER_FEATURE_ACTION featureAction
+    );
+
+LPCSTR LoggingMsiInstallContext(
+    __in MSIINSTALLCONTEXT context
+    );
+
+LPCSTR LoggingPerMachineToString(
+    __in BOOL fPerMachine
+    );
+
+LPCSTR LoggingRestartToString(
+    __in BOOTSTRAPPER_APPLY_RESTART restart
+    );
+
+LPCSTR LoggingResumeModeToString(
+    __in BURN_RESUME_MODE resumeMode
+    );
+
+LPCSTR LoggingRelationTypeToString(
+    __in BOOTSTRAPPER_RELATION_TYPE type
+    );
+
+LPCSTR LoggingRelatedOperationToString(
+    __in BOOTSTRAPPER_RELATED_OPERATION operation
+    );
+
+LPCSTR LoggingRequestStateToString(
+    __in BOOTSTRAPPER_REQUEST_STATE requestState
+    );
+
+LPCSTR LoggingRollbackOrExecute(
+    __in BOOL fRollback
+    );
+
+LPWSTR LoggingStringOrUnknownIfNull(
+    __in LPCWSTR wz
+    );
+
+// Note: this function is not thread safe.
+LPCSTR LoggingVersionToString(
+    __in DWORD64 dw64Version
+    );
+
+
+#if defined(__cplusplus)
+}
+#endif
diff --git a/src/engine/manifest.cpp b/src/engine/manifest.cpp
new file mode 100644
index 00000000..c2214a89
--- /dev/null
+++ b/src/engine/manifest.cpp
@@ -0,0 +1,125 @@
+// 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.
+
+#include "precomp.h"
+
+
+// function definitions
+
+extern "C" HRESULT ManifestLoadXmlFromBuffer(
+    __in_bcount(cbBuffer) BYTE* pbBuffer,
+    __in SIZE_T cbBuffer,
+    __in BURN_ENGINE_STATE* pEngineState
+    )
+{
+    HRESULT hr = S_OK;
+    IXMLDOMDocument* pixdDocument = NULL;
+    IXMLDOMElement* pixeBundle = NULL;
+    IXMLDOMNode* pixnLog = NULL;
+    IXMLDOMNode* pixnChain = NULL;
+
+    // load xml document
+    hr = XmlLoadDocumentFromBuffer(pbBuffer, cbBuffer, &pixdDocument);
+    ExitOnFailure(hr, "Failed to load manifest as XML document.");
+
+    // get bundle element
+    hr = pixdDocument->get_documentElement(&pixeBundle);
+    ExitOnFailure(hr, "Failed to get bundle element.");
+
+    // parse the log element, if present.
+    hr = XmlSelectSingleNode(pixeBundle, L"Log", &pixnLog);
+    ExitOnFailure(hr, "Failed to get Log element.");
+
+    if (S_OK == hr)
+    {
+        hr = XmlGetAttributeEx(pixnLog, L"PathVariable", &pEngineState->log.sczPathVariable);
+        if (E_NOTFOUND != hr)
+        {
+            ExitOnFailure(hr, "Failed to get Log/@PathVariable.");
+        }
+
+        hr = XmlGetAttributeEx(pixnLog, L"Prefix", &pEngineState->log.sczPrefix);
+        ExitOnFailure(hr, "Failed to get Log/@Prefix attribute.");
+
+        hr = XmlGetAttributeEx(pixnLog, L"Extension", &pEngineState->log.sczExtension);
+        ExitOnFailure(hr, "Failed to get Log/@Extension attribute.");
+    }
+
+    // get the chain element
+    hr = XmlSelectSingleNode(pixeBundle, L"Chain", &pixnChain);
+    ExitOnFailure(hr, "Failed to get chain element.");
+
+    if (S_OK == hr)
+    {
+        // parse disable rollback
+        hr = XmlGetYesNoAttribute(pixnChain, L"DisableRollback", &pEngineState->fDisableRollback);
+        if (E_NOTFOUND != hr)
+        {
+            ExitOnFailure(hr, "Failed to get Chain/@DisableRollback");
+        }
+
+        // parse disable system restore
+        hr = XmlGetYesNoAttribute(pixnChain, L"DisableSystemRestore", &pEngineState->fDisableSystemRestore);
+        if (E_NOTFOUND != hr)
+        {
+            ExitOnFailure(hr, "Failed to get Chain/@DisableSystemRestore");
+        }
+
+        // parse parallel cache
+        hr = XmlGetYesNoAttribute(pixnChain, L"ParallelCache", &pEngineState->fParallelCacheAndExecute);
+        if (E_NOTFOUND != hr)
+        {
+            ExitOnFailure(hr, "Failed to get Chain/@ParallelCache");
+        }
+    }
+
+    // parse built-in condition 
+    hr = ConditionGlobalParseFromXml(&pEngineState->condition, pixeBundle);
+    ExitOnFailure(hr, "Failed to parse global condition.");
+
+    // parse variables
+    hr = VariablesParseFromXml(&pEngineState->variables, pixeBundle);
+    ExitOnFailure(hr, "Failed to parse variables.");
+
+    // parse searches
+    hr = SearchesParseFromXml(&pEngineState->searches, pixeBundle); // TODO: Modularization
+    ExitOnFailure(hr, "Failed to parse searches.");
+
+    // parse user experience
+    hr = UserExperienceParseFromXml(&pEngineState->userExperience, pixeBundle);
+    ExitOnFailure(hr, "Failed to parse user experience.");
+
+    // parse catalog files
+    hr = CatalogsParseFromXml(&pEngineState->catalogs, pixeBundle);
+    ExitOnFailure(hr, "Failed to parse catalog files.");
+
+    // parse registration
+    hr = RegistrationParseFromXml(&pEngineState->registration, pixeBundle);
+    ExitOnFailure(hr, "Failed to parse registration.");
+
+    // parse update
+    hr = UpdateParseFromXml(&pEngineState->update, pixeBundle);
+    ExitOnFailure(hr, "Failed to parse update.");
+
+    // parse containers
+    hr = ContainersParseFromXml(&pEngineState->section, &pEngineState->containers, pixeBundle);
+    ExitOnFailure(hr, "Failed to parse containers.");
+
+    // parse payloads
+    hr = PayloadsParseFromXml(&pEngineState->payloads, &pEngineState->containers, &pEngineState->catalogs, pixeBundle);
+    ExitOnFailure(hr, "Failed to parse payloads.");
+
+    // parse packages
+    hr = PackagesParseFromXml(&pEngineState->packages, &pEngineState->payloads, pixeBundle);
+    ExitOnFailure(hr, "Failed to parse packages.");
+
+    // parse approved exes for elevation
+    hr = ApprovedExesParseFromXml(&pEngineState->approvedExes, pixeBundle);
+    ExitOnFailure(hr, "Failed to parse approved exes.");
+
+LExit:
+    ReleaseObject(pixnChain);
+    ReleaseObject(pixnLog);
+    ReleaseObject(pixeBundle);
+    ReleaseObject(pixdDocument);
+    return hr;
+}
diff --git a/src/engine/manifest.h b/src/engine/manifest.h
new file mode 100644
index 00000000..6e535d60
--- /dev/null
+++ b/src/engine/manifest.h
@@ -0,0 +1,23 @@
+#pragma once
+// 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.
+
+
+interface IBurnPayload; // forward declare.
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+
+// function declarations
+
+HRESULT ManifestLoadXmlFromBuffer(
+    __in_bcount(cbBuffer) BYTE* pbBuffer,
+    __in SIZE_T cbBuffer,
+    __in BURN_ENGINE_STATE* pEngineState
+    );
+
+
+#if defined(__cplusplus)
+}
+#endif
diff --git a/src/engine/msiengine.cpp b/src/engine/msiengine.cpp
new file mode 100644
index 00000000..17571ac5
--- /dev/null
+++ b/src/engine/msiengine.cpp
@@ -0,0 +1,1910 @@
+// 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.
+
+#include "precomp.h"
+
+
+// constants
+
+
+// structs
+
+
+
+// internal function declarations
+
+static HRESULT ParseRelatedMsiFromXml(
+    __in IXMLDOMNode* pixnRelatedMsi,
+    __in BURN_RELATED_MSI* pRelatedMsi
+    );
+static HRESULT EvaluateActionStateConditions(
+    __in BURN_VARIABLES* pVariables,
+    __in_z_opt LPCWSTR sczAddLocalCondition,
+    __in_z_opt LPCWSTR sczAddSourceCondition,
+    __in_z_opt LPCWSTR sczAdvertiseCondition,
+    __out BOOTSTRAPPER_FEATURE_STATE* pState
+    );
+static HRESULT CalculateFeatureAction(
+    __in BOOTSTRAPPER_FEATURE_STATE currentState,
+    __in BOOTSTRAPPER_FEATURE_STATE requestedState,
+    __in BOOL fRepair,
+    __out BOOTSTRAPPER_FEATURE_ACTION* pFeatureAction,
+    __inout BOOL* pfDelta
+    );
+static HRESULT EscapePropertyArgumentString(
+    __in LPCWSTR wzProperty,
+    __inout_z LPWSTR* psczEscapedValue,
+    __in BOOL fZeroOnRealloc
+    );
+static HRESULT ConcatFeatureActionProperties(
+    __in BURN_PACKAGE* pPackage,
+    __in BOOTSTRAPPER_FEATURE_ACTION* rgFeatureActions,
+    __inout_z LPWSTR* psczArguments
+    );
+static HRESULT ConcatPatchProperty(
+    __in BURN_PACKAGE* pPackage,
+    __in_opt BOOTSTRAPPER_ACTION_STATE* rgSlipstreamPatchActions,
+    __inout_z LPWSTR* psczArguments
+    );
+static void RegisterSourceDirectory(
+    __in BURN_PACKAGE* pPackage,
+    __in_z LPCWSTR wzCacheDirectory
+    );
+
+
+// function definitions
+
+extern "C" HRESULT MsiEngineParsePackageFromXml(
+    __in IXMLDOMNode* pixnMsiPackage,
+    __in BURN_PACKAGE* pPackage
+    )
+{
+    HRESULT hr = S_OK;
+    IXMLDOMNodeList* pixnNodes = NULL;
+    IXMLDOMNode* pixnNode = NULL;
+    DWORD cNodes = 0;
+    LPWSTR scz = NULL;
+
+    // @ProductCode
+    hr = XmlGetAttributeEx(pixnMsiPackage, L"ProductCode", &pPackage->Msi.sczProductCode);
+    ExitOnFailure(hr, "Failed to get @ProductCode.");
+
+    // @Language
+    hr = XmlGetAttributeNumber(pixnMsiPackage, L"Language", &pPackage->Msi.dwLanguage);
+    ExitOnFailure(hr, "Failed to get @Language.");
+
+    // @Version
+    hr = XmlGetAttributeEx(pixnMsiPackage, L"Version", &scz);
+    ExitOnFailure(hr, "Failed to get @Version.");
+
+    hr = FileVersionFromStringEx(scz, 0, &pPackage->Msi.qwVersion);
+    ExitOnFailure(hr, "Failed to parse @Version: %ls", scz);
+
+    // @DisplayInternalUI
+    hr = XmlGetYesNoAttribute(pixnMsiPackage, L"DisplayInternalUI", &pPackage->Msi.fDisplayInternalUI);
+    ExitOnFailure(hr, "Failed to get @DisplayInternalUI.");
+
+    // @UpgradeCode
+    hr = XmlGetAttributeEx(pixnMsiPackage, L"UpgradeCode", &pPackage->Msi.sczUpgradeCode);
+    if (E_NOTFOUND != hr)
+    {
+        ExitOnFailure(hr, "Failed to get @UpgradeCode.");
+    }
+
+    // select feature nodes
+    hr = XmlSelectNodes(pixnMsiPackage, L"MsiFeature", &pixnNodes);
+    ExitOnFailure(hr, "Failed to select feature nodes.");
+
+    // get feature node count
+    hr = pixnNodes->get_length((long*)&cNodes);
+    ExitOnFailure(hr, "Failed to get feature node count.");
+
+    if (cNodes)
+    {
+        // allocate memory for features
+        pPackage->Msi.rgFeatures = (BURN_MSIFEATURE*)MemAlloc(sizeof(BURN_MSIFEATURE) * cNodes, TRUE);
+        ExitOnNull(pPackage->Msi.rgFeatures, hr, E_OUTOFMEMORY, "Failed to allocate memory for MSI feature structs.");
+
+        pPackage->Msi.cFeatures = cNodes;
+
+        // parse feature elements
+        for (DWORD i = 0; i < cNodes; ++i)
+        {
+            BURN_MSIFEATURE* pFeature = &pPackage->Msi.rgFeatures[i];
+
+            hr = XmlNextElement(pixnNodes, &pixnNode, NULL);
+            ExitOnFailure(hr, "Failed to get next node.");
+
+            // @Id
+            hr = XmlGetAttributeEx(pixnNode, L"Id", &pFeature->sczId);
+            ExitOnFailure(hr, "Failed to get @Id.");
+
+            // @AddLocalCondition
+            hr = XmlGetAttributeEx(pixnNode, L"AddLocalCondition", &pFeature->sczAddLocalCondition);
+            if (E_NOTFOUND != hr)
+            {
+                ExitOnFailure(hr, "Failed to get @AddLocalCondition.");
+            }
+
+            // @AddSourceCondition
+            hr = XmlGetAttributeEx(pixnNode, L"AddSourceCondition", &pFeature->sczAddSourceCondition);
+            if (E_NOTFOUND != hr)
+            {
+                ExitOnFailure(hr, "Failed to get @AddSourceCondition.");
+            }
+
+            // @AdvertiseCondition
+            hr = XmlGetAttributeEx(pixnNode, L"AdvertiseCondition", &pFeature->sczAdvertiseCondition);
+            if (E_NOTFOUND != hr)
+            {
+                ExitOnFailure(hr, "Failed to get @AdvertiseCondition.");
+            }
+
+            // @RollbackAddLocalCondition
+            hr = XmlGetAttributeEx(pixnNode, L"RollbackAddLocalCondition", &pFeature->sczRollbackAddLocalCondition);
+            if (E_NOTFOUND != hr)
+            {
+                ExitOnFailure(hr, "Failed to get @RollbackAddLocalCondition.");
+            }
+
+            // @RollbackAddSourceCondition
+            hr = XmlGetAttributeEx(pixnNode, L"RollbackAddSourceCondition", &pFeature->sczRollbackAddSourceCondition);
+            if (E_NOTFOUND != hr)
+            {
+                ExitOnFailure(hr, "Failed to get @RollbackAddSourceCondition.");
+            }
+
+            // @RollbackAdvertiseCondition
+            hr = XmlGetAttributeEx(pixnNode, L"RollbackAdvertiseCondition", &pFeature->sczRollbackAdvertiseCondition);
+            if (E_NOTFOUND != hr)
+            {
+                ExitOnFailure(hr, "Failed to get @RollbackAdvertiseCondition.");
+            }
+
+            // prepare next iteration
+            ReleaseNullObject(pixnNode);
+        }
+    }
+
+    ReleaseNullObject(pixnNodes); // done with the MsiFeature elements.
+
+    hr = MsiEngineParsePropertiesFromXml(pixnMsiPackage, &pPackage->Msi.rgProperties, &pPackage->Msi.cProperties);
+    ExitOnFailure(hr, "Failed to parse properties from XML.");
+
+    // select related MSI nodes
+    hr = XmlSelectNodes(pixnMsiPackage, L"RelatedPackage", &pixnNodes);
+    ExitOnFailure(hr, "Failed to select related MSI nodes.");
+
+    // get related MSI node count
+    hr = pixnNodes->get_length((long*)&cNodes);
+    ExitOnFailure(hr, "Failed to get related MSI node count.");
+
+    if (cNodes)
+    {
+        // allocate memory for related MSIs
+        pPackage->Msi.rgRelatedMsis = (BURN_RELATED_MSI*)MemAlloc(sizeof(BURN_RELATED_MSI) * cNodes, TRUE);
+        ExitOnNull(pPackage->Msi.rgRelatedMsis, hr, E_OUTOFMEMORY, "Failed to allocate memory for related MSI structs.");
+
+        pPackage->Msi.cRelatedMsis = cNodes;
+
+        // parse related MSI elements
+        for (DWORD i = 0; i < cNodes; ++i)
+        {
+            hr = XmlNextElement(pixnNodes, &pixnNode, NULL);
+            ExitOnFailure(hr, "Failed to get next node.");
+
+            // parse related MSI element
+            hr = ParseRelatedMsiFromXml(pixnNode, &pPackage->Msi.rgRelatedMsis[i]);
+            ExitOnFailure(hr, "Failed to parse related MSI element.");
+
+            // prepare next iteration
+            ReleaseNullObject(pixnNode);
+        }
+    }
+
+    ReleaseNullObject(pixnNodes); // done with the RelatedPackage elements.
+
+    // Select slipstream MSP nodes.
+    hr = XmlSelectNodes(pixnMsiPackage, L"SlipstreamMsp", &pixnNodes);
+    ExitOnFailure(hr, "Failed to select related MSI nodes.");
+
+    hr = pixnNodes->get_length((long*)&cNodes);
+    ExitOnFailure(hr, "Failed to get related MSI node count.");
+
+    if (cNodes)
+    {
+        pPackage->Msi.rgpSlipstreamMspPackages = reinterpret_cast<BURN_PACKAGE**>(MemAlloc(sizeof(BURN_PACKAGE*) * cNodes, TRUE));
+        ExitOnNull(pPackage->Msi.rgpSlipstreamMspPackages, hr, E_OUTOFMEMORY, "Failed to allocate memory for slipstream MSP packages.");
+
+        pPackage->Msi.rgsczSlipstreamMspPackageIds = reinterpret_cast<LPWSTR*>(MemAlloc(sizeof(LPWSTR*) * cNodes, TRUE));
+        ExitOnNull(pPackage->Msi.rgsczSlipstreamMspPackageIds, hr, E_OUTOFMEMORY, "Failed to allocate memory for slipstream MSP ids.");
+
+        pPackage->Msi.cSlipstreamMspPackages = cNodes;
+
+        // Parse slipstream MSP Ids.
+        for (DWORD i = 0; i < cNodes; ++i)
+        {
+            hr = XmlNextElement(pixnNodes, &pixnNode, NULL);
+            ExitOnFailure(hr, "Failed to get next slipstream MSP node.");
+
+            hr = XmlGetAttributeEx(pixnNode, L"Id", pPackage->Msi.rgsczSlipstreamMspPackageIds + i);
+            ExitOnFailure(hr, "Failed to parse slipstream MSP ids.");
+
+            ReleaseNullObject(pixnNode);
+        }
+    }
+
+    hr = S_OK;
+
+LExit:
+    ReleaseObject(pixnNodes);
+    ReleaseObject(pixnNode);
+    ReleaseStr(scz);
+
+    return hr;
+}
+
+extern "C" HRESULT MsiEngineParsePropertiesFromXml(
+    __in IXMLDOMNode* pixnPackage,
+    __out BURN_MSIPROPERTY** prgProperties,
+    __out DWORD* pcProperties
+    )
+{
+    HRESULT hr = S_OK;
+    IXMLDOMNodeList* pixnNodes = NULL;
+    IXMLDOMNode* pixnNode = NULL;
+    DWORD cNodes = 0;
+
+    BURN_MSIPROPERTY* pProperties = NULL;
+
+    // select property nodes
+    hr = XmlSelectNodes(pixnPackage, L"MsiProperty", &pixnNodes);
+    ExitOnFailure(hr, "Failed to select property nodes.");
+
+    // get property node count
+    hr = pixnNodes->get_length((long*)&cNodes);
+    ExitOnFailure(hr, "Failed to get property node count.");
+
+    if (cNodes)
+    {
+        // allocate memory for properties
+        pProperties = (BURN_MSIPROPERTY*)MemAlloc(sizeof(BURN_MSIPROPERTY) * cNodes, TRUE);
+        ExitOnNull(pProperties, hr, E_OUTOFMEMORY, "Failed to allocate memory for MSI property structs.");
+
+        // parse property elements
+        for (DWORD i = 0; i < cNodes; ++i)
+        {
+            BURN_MSIPROPERTY* pProperty = &pProperties[i];
+
+            hr = XmlNextElement(pixnNodes, &pixnNode, NULL);
+            ExitOnFailure(hr, "Failed to get next node.");
+
+            // @Id
+            hr = XmlGetAttributeEx(pixnNode, L"Id", &pProperty->sczId);
+            ExitOnFailure(hr, "Failed to get @Id.");
+
+            // @Value
+            hr = XmlGetAttributeEx(pixnNode, L"Value", &pProperty->sczValue);
+            ExitOnFailure(hr, "Failed to get @Value.");
+
+            // @RollbackValue
+            hr = XmlGetAttributeEx(pixnNode, L"RollbackValue", &pProperty->sczRollbackValue);
+            if (E_NOTFOUND != hr)
+            {
+                ExitOnFailure(hr, "Failed to get @RollbackValue.");
+            }
+
+            // @Condition
+            hr = XmlGetAttributeEx(pixnNode, L"Condition", &pProperty->sczCondition);
+            if (E_NOTFOUND != hr)
+            {
+                ExitOnFailure(hr, "Failed to get @Condition.");
+            }
+
+            // prepare next iteration
+            ReleaseNullObject(pixnNode);
+        }
+    }
+
+    *pcProperties = cNodes;
+    *prgProperties = pProperties;
+    pProperties = NULL;
+
+    hr = S_OK;
+
+LExit:
+    ReleaseNullObject(pixnNodes);
+    ReleaseMem(pProperties);
+
+    return hr;
+}
+
+extern "C" void MsiEnginePackageUninitialize(
+    __in BURN_PACKAGE* pPackage
+    )
+{
+    ReleaseStr(pPackage->Msi.sczProductCode);
+    ReleaseStr(pPackage->Msi.sczUpgradeCode);
+    ReleaseStr(pPackage->Msi.sczInstalledProductCode);
+
+    // free features
+    if (pPackage->Msi.rgFeatures)
+    {
+        for (DWORD i = 0; i < pPackage->Msi.cFeatures; ++i)
+        {
+            BURN_MSIFEATURE* pFeature = &pPackage->Msi.rgFeatures[i];
+
+            ReleaseStr(pFeature->sczId);
+            ReleaseStr(pFeature->sczAddLocalCondition);
+            ReleaseStr(pFeature->sczAddSourceCondition);
+            ReleaseStr(pFeature->sczAdvertiseCondition);
+            ReleaseStr(pFeature->sczRollbackAddLocalCondition);
+            ReleaseStr(pFeature->sczRollbackAddSourceCondition);
+            ReleaseStr(pFeature->sczRollbackAdvertiseCondition);
+        }
+        MemFree(pPackage->Msi.rgFeatures);
+    }
+
+    // free properties
+    if (pPackage->Msi.rgProperties)
+    {
+        for (DWORD i = 0; i < pPackage->Msi.cProperties; ++i)
+        {
+            BURN_MSIPROPERTY* pProperty = &pPackage->Msi.rgProperties[i];
+
+            ReleaseStr(pProperty->sczId);
+            ReleaseStr(pProperty->sczValue);
+            ReleaseStr(pProperty->sczRollbackValue);
+            ReleaseStr(pProperty->sczCondition);
+        }
+        MemFree(pPackage->Msi.rgProperties);
+    }
+
+    // free related MSIs
+    if (pPackage->Msi.rgRelatedMsis)
+    {
+        for (DWORD i = 0; i < pPackage->Msi.cRelatedMsis; ++i)
+        {
+            BURN_RELATED_MSI* pRelatedMsi = &pPackage->Msi.rgRelatedMsis[i];
+
+            ReleaseStr(pRelatedMsi->sczUpgradeCode);
+            ReleaseMem(pRelatedMsi->rgdwLanguages);
+        }
+        MemFree(pPackage->Msi.rgRelatedMsis);
+    }
+
+    // free slipstream MSPs
+    if (pPackage->Msi.rgsczSlipstreamMspPackageIds)
+    {
+        for (DWORD i = 0; i < pPackage->Msi.cSlipstreamMspPackages; ++i)
+        {
+            ReleaseStr(pPackage->Msi.rgsczSlipstreamMspPackageIds[i]);
+        }
+
+        MemFree(pPackage->Msi.rgsczSlipstreamMspPackageIds);
+    }
+
+    if (pPackage->Msi.rgpSlipstreamMspPackages)
+    {
+        MemFree(pPackage->Msi.rgpSlipstreamMspPackages);
+    }
+
+    // clear struct
+    memset(&pPackage->Msi, 0, sizeof(pPackage->Msi));
+}
+
+extern "C" HRESULT MsiEngineDetectPackage(
+    __in BURN_PACKAGE* pPackage,
+    __in BURN_USER_EXPERIENCE* pUserExperience
+    )
+{
+    Trace(REPORT_STANDARD, "Detecting MSI package 0x%p", pPackage);
+
+    HRESULT hr = S_OK;
+    LPWSTR sczInstalledVersion = NULL;
+    LPWSTR sczInstalledLanguage = NULL;
+    LPWSTR sczInstalledProductCode = NULL;
+    LPWSTR sczInstalledProviderKey = NULL;
+    INSTALLSTATE installState = INSTALLSTATE_UNKNOWN;
+    BOOTSTRAPPER_RELATED_OPERATION operation = BOOTSTRAPPER_RELATED_OPERATION_NONE;
+    BOOTSTRAPPER_RELATED_OPERATION relatedMsiOperation = BOOTSTRAPPER_RELATED_OPERATION_NONE;
+    WCHAR wzProductCode[MAX_GUID_CHARS + 1] = { };
+    DWORD64 qwVersion = 0;
+    UINT uLcid = 0;
+    BOOL fPerMachine = FALSE;
+
+    // detect self by product code
+    // TODO: what to do about MSIINSTALLCONTEXT_USERMANAGED?
+    hr = WiuGetProductInfoEx(pPackage->Msi.sczProductCode, NULL, pPackage->fPerMachine ? MSIINSTALLCONTEXT_MACHINE : MSIINSTALLCONTEXT_USERUNMANAGED, INSTALLPROPERTY_VERSIONSTRING, &sczInstalledVersion);
+    if (SUCCEEDED(hr))
+    {
+        hr = FileVersionFromStringEx(sczInstalledVersion, 0, &pPackage->Msi.qwInstalledVersion);
+        ExitOnFailure(hr, "Failed to convert version: %ls to DWORD64 for ProductCode: %ls", sczInstalledVersion, pPackage->Msi.sczProductCode);
+
+        // compare versions
+        if (pPackage->Msi.qwVersion < pPackage->Msi.qwInstalledVersion)
+        {
+            operation = BOOTSTRAPPER_RELATED_OPERATION_DOWNGRADE;
+            pPackage->currentState = BOOTSTRAPPER_PACKAGE_STATE_SUPERSEDED;
+        }
+        else
+        {
+            if (pPackage->Msi.qwVersion > pPackage->Msi.qwInstalledVersion)
+            {
+                operation = BOOTSTRAPPER_RELATED_OPERATION_MINOR_UPDATE;
+            }
+
+            pPackage->currentState = BOOTSTRAPPER_PACKAGE_STATE_PRESENT;
+        }
+
+        // Report related MSI package to BA.
+        if (BOOTSTRAPPER_RELATED_OPERATION_NONE != operation)
+        {
+            LogId(REPORT_STANDARD, MSG_DETECTED_RELATED_PACKAGE, pPackage->Msi.sczProductCode, LoggingPerMachineToString(pPackage->fPerMachine), LoggingVersionToString(pPackage->Msi.qwInstalledVersion), pPackage->Msi.dwLanguage, LoggingRelatedOperationToString(operation));
+
+            hr = UserExperienceOnDetectRelatedMsiPackage(pUserExperience, pPackage->sczId, pPackage->Msi.sczUpgradeCode, pPackage->Msi.sczProductCode, pPackage->fPerMachine, pPackage->Msi.qwInstalledVersion, operation);
+            ExitOnRootFailure(hr, "BA aborted detect related MSI package.");
+        }
+    }
+    else if (HRESULT_FROM_WIN32(ERROR_UNKNOWN_PRODUCT) == hr || HRESULT_FROM_WIN32(ERROR_UNKNOWN_PROPERTY) == hr) // package not present.
+    {
+        // Check for newer, compatible packages based on a fixed provider key.
+        hr = DependencyDetectProviderKeyPackageId(pPackage, &sczInstalledProviderKey, &sczInstalledProductCode);
+        if (SUCCEEDED(hr))
+        {
+            hr = WiuGetProductInfoEx(sczInstalledProductCode, NULL, pPackage->fPerMachine ? MSIINSTALLCONTEXT_MACHINE : MSIINSTALLCONTEXT_USERUNMANAGED, INSTALLPROPERTY_VERSIONSTRING, &sczInstalledVersion);
+            if (SUCCEEDED(hr))
+            {
+                hr = FileVersionFromStringEx(sczInstalledVersion, 0, &qwVersion);
+                ExitOnFailure(hr, "Failed to convert version: %ls to DWORD64 for ProductCode: %ls", sczInstalledVersion, sczInstalledProductCode);
+
+                if (pPackage->Msi.qwVersion < qwVersion)
+                {
+                    LogId(REPORT_STANDARD, MSG_DETECTED_COMPATIBLE_PACKAGE_FROM_PROVIDER, pPackage->sczId, sczInstalledProviderKey, sczInstalledProductCode, sczInstalledVersion, pPackage->Msi.sczProductCode);
+
+                    hr = UserExperienceOnDetectCompatibleMsiPackage(pUserExperience, pPackage->sczId, sczInstalledProductCode, qwVersion);
+                    ExitOnRootFailure(hr, "BA aborted detect compatible MSI package.");
+
+                    hr = StrAllocString(&pPackage->Msi.sczInstalledProductCode, sczInstalledProductCode, 0);
+                    ExitOnFailure(hr, "Failed to copy the installed ProductCode to the package.");
+
+                    pPackage->Msi.qwInstalledVersion = qwVersion;
+                    pPackage->Msi.fCompatibleInstalled = TRUE;
+                }
+            }
+        }
+
+        pPackage->currentState = BOOTSTRAPPER_PACKAGE_STATE_ABSENT;
+        hr = S_OK;
+    }
+    else
+    {
+        ExitOnFailure(hr, "Failed to get product information for ProductCode: %ls", pPackage->Msi.sczProductCode);
+    }
+
+    // detect related packages by upgrade code
+    for (DWORD i = 0; i < pPackage->Msi.cRelatedMsis; ++i)
+    {
+        BURN_RELATED_MSI* pRelatedMsi = &pPackage->Msi.rgRelatedMsis[i];
+
+        for (DWORD iProduct = 0; ; ++iProduct)
+        {
+            // get product
+            hr = WiuEnumRelatedProducts(pRelatedMsi->sczUpgradeCode, iProduct, wzProductCode);
+            if (E_NOMOREITEMS == hr)
+            {
+                hr = S_OK;
+                break;
+            }
+            ExitOnFailure(hr, "Failed to enum related products.");
+
+            // If we found ourselves, skip because saying that a package is related to itself is nonsensical.
+            if (CSTR_EQUAL == ::CompareStringW(LOCALE_NEUTRAL, NORM_IGNORECASE, pPackage->Msi.sczProductCode, -1, wzProductCode, -1))
+            {
+                continue;
+            }
+
+            // get product version
+            hr = WiuGetProductInfoEx(wzProductCode, NULL, MSIINSTALLCONTEXT_USERUNMANAGED, INSTALLPROPERTY_VERSIONSTRING, &sczInstalledVersion);
+            if (HRESULT_FROM_WIN32(ERROR_UNKNOWN_PRODUCT) != hr && HRESULT_FROM_WIN32(ERROR_UNKNOWN_PROPERTY) != hr)
+            {
+                ExitOnFailure(hr, "Failed to get version for product in user unmanaged context: %ls", wzProductCode);
+                fPerMachine = FALSE;
+            }
+            else
+            {
+                hr = WiuGetProductInfoEx(wzProductCode, NULL, MSIINSTALLCONTEXT_MACHINE, INSTALLPROPERTY_VERSIONSTRING, &sczInstalledVersion);
+                if (HRESULT_FROM_WIN32(ERROR_UNKNOWN_PRODUCT) != hr && HRESULT_FROM_WIN32(ERROR_UNKNOWN_PROPERTY) != hr)
+                {
+                    ExitOnFailure(hr, "Failed to get version for product in machine context: %ls", wzProductCode);
+                    fPerMachine = TRUE;
+                }
+                else
+                {
+                    hr = S_OK;
+                    continue;
+                }
+            }
+
+            hr = FileVersionFromStringEx(sczInstalledVersion, 0, &qwVersion);
+            ExitOnFailure(hr, "Failed to convert version: %ls to DWORD64 for ProductCode: %ls", sczInstalledVersion, wzProductCode);
+
+            // compare versions
+            if (pRelatedMsi->fMinProvided && (pRelatedMsi->fMinInclusive ? (qwVersion < pRelatedMsi->qwMinVersion) : (qwVersion <= pRelatedMsi->qwMinVersion)))
+            {
+                continue;
+            }
+
+            if (pRelatedMsi->fMaxProvided && (pRelatedMsi->fMaxInclusive ? (qwVersion > pRelatedMsi->qwMaxVersion) : (qwVersion >= pRelatedMsi->qwMaxVersion)))
+            {
+                continue;
+            }
+
+            // Filter by language if necessary.
+            uLcid = 0; // always reset the found language.
+            if (pRelatedMsi->cLanguages)
+            {
+                // If there is a language to get, convert it into an LCID.
+                hr = WiuGetProductInfoEx(wzProductCode, NULL, fPerMachine ? MSIINSTALLCONTEXT_MACHINE : MSIINSTALLCONTEXT_USERUNMANAGED, INSTALLPROPERTY_LANGUAGE, &sczInstalledLanguage);
+                if (SUCCEEDED(hr))
+                {
+                    hr = StrStringToUInt32(sczInstalledLanguage, 0, &uLcid);
+                }
+
+                // Ignore related product where we can't read the language.
+                if (FAILED(hr))
+                {
+                    LogErrorId(hr, MSG_FAILED_READ_RELATED_PACKAGE_LANGUAGE, wzProductCode, sczInstalledLanguage, NULL);
+
+                    hr = S_OK;
+                    continue;
+                }
+
+                BOOL fMatchedLcid = FALSE;
+                for (DWORD iLanguage = 0; iLanguage < pRelatedMsi->cLanguages; ++iLanguage)
+                {
+                    if (uLcid == pRelatedMsi->rgdwLanguages[iLanguage])
+                    {
+                        fMatchedLcid = TRUE;
+                        break;
+                    }
+                }
+
+                // Skip the product if the language did not meet the inclusive/exclusive criteria.
+                if ((pRelatedMsi->fLangInclusive && !fMatchedLcid) || (!pRelatedMsi->fLangInclusive && fMatchedLcid))
+                {
+                    continue;
+                }
+            }
+
+            // If this is a detect-only related package and we're not installed yet, then we'll assume a downgrade
+            // would take place since that is the overwhelmingly common use of detect-only related packages. If
+            // not detect-only then it's easy; we're clearly doing a major upgrade.
+            if (pRelatedMsi->fOnlyDetect)
+            {
+                // If we've already detected a major upgrade that trumps any guesses that the detect is a downgrade
+                // or even something else.
+                if (BOOTSTRAPPER_RELATED_OPERATION_MAJOR_UPGRADE == operation)
+                {
+                    relatedMsiOperation = BOOTSTRAPPER_RELATED_OPERATION_NONE;
+                }
+                // It can't be a downgrade if the upgrade codes aren't the same.
+                else if (BOOTSTRAPPER_PACKAGE_STATE_ABSENT == pPackage->currentState &&
+                         pPackage->Msi.sczUpgradeCode && CSTR_EQUAL == ::CompareStringW(LOCALE_NEUTRAL, NORM_IGNORECASE, pPackage->Msi.sczUpgradeCode, -1, pRelatedMsi->sczUpgradeCode, -1))
+                {
+                    relatedMsiOperation = BOOTSTRAPPER_RELATED_OPERATION_DOWNGRADE;
+                    operation = BOOTSTRAPPER_RELATED_OPERATION_DOWNGRADE;
+                    pPackage->currentState = BOOTSTRAPPER_PACKAGE_STATE_OBSOLETE;
+                }
+                else // we're already on the machine so the detect-only *must* be for detection purposes only.
+                {
+                    relatedMsiOperation = BOOTSTRAPPER_RELATED_OPERATION_NONE;
+                }
+            }
+            else
+            {
+                relatedMsiOperation = BOOTSTRAPPER_RELATED_OPERATION_MAJOR_UPGRADE;
+                operation = BOOTSTRAPPER_RELATED_OPERATION_MAJOR_UPGRADE;
+            }
+
+            LogId(REPORT_STANDARD, MSG_DETECTED_RELATED_PACKAGE, wzProductCode, LoggingPerMachineToString(fPerMachine), LoggingVersionToString(qwVersion), uLcid, LoggingRelatedOperationToString(relatedMsiOperation));
+
+            // Pass to BA.
+            hr = UserExperienceOnDetectRelatedMsiPackage(pUserExperience, pPackage->sczId, pRelatedMsi->sczUpgradeCode, wzProductCode, fPerMachine, qwVersion, relatedMsiOperation);
+            ExitOnRootFailure(hr, "BA aborted detect related MSI package.");
+        }
+    }
+
+    // detect features
+    if (pPackage->Msi.cFeatures)
+    {
+        for (DWORD i = 0; i < pPackage->Msi.cFeatures; ++i)
+        {
+            BURN_MSIFEATURE* pFeature = &pPackage->Msi.rgFeatures[i];
+
+            // Try to detect features state if the product is present on the machine.
+            if (BOOTSTRAPPER_PACKAGE_STATE_PRESENT <= pPackage->currentState)
+            {
+                hr = WiuQueryFeatureState(pPackage->Msi.sczProductCode, pFeature->sczId, &installState);
+                ExitOnFailure(hr, "Failed to query feature state.");
+
+                if (INSTALLSTATE_UNKNOWN == installState) // in case of an upgrade a feature could be removed.
+                {
+                    installState = INSTALLSTATE_ABSENT;
+                }
+            }
+            else // MSI not installed then the features can't be either.
+            {
+                installState = INSTALLSTATE_ABSENT;
+            }
+
+            // set current state
+            switch (installState)
+            {
+            case INSTALLSTATE_ABSENT:
+                pFeature->currentState = BOOTSTRAPPER_FEATURE_STATE_ABSENT;
+                break;
+            case INSTALLSTATE_ADVERTISED:
+                pFeature->currentState = BOOTSTRAPPER_FEATURE_STATE_ADVERTISED;
+                break;
+            case INSTALLSTATE_LOCAL:
+                pFeature->currentState = BOOTSTRAPPER_FEATURE_STATE_LOCAL;
+                break;
+            case INSTALLSTATE_SOURCE:
+                pFeature->currentState = BOOTSTRAPPER_FEATURE_STATE_SOURCE;
+                break;
+            default:
+                hr = E_UNEXPECTED;
+                ExitOnRootFailure(hr, "Invalid state value.");
+            }
+
+            // Pass to BA.
+            hr = UserExperienceOnDetectMsiFeature(pUserExperience, pPackage->sczId, pFeature->sczId, pFeature->currentState);
+            ExitOnRootFailure(hr, "BA aborted detect MSI feature.");
+        }
+    }
+
+LExit:
+    ReleaseStr(sczInstalledProviderKey);
+    ReleaseStr(sczInstalledProductCode);
+    ReleaseStr(sczInstalledLanguage);
+    ReleaseStr(sczInstalledVersion);
+
+    return hr;
+}
+
+//
+// PlanCalculate - calculates the execute and rollback state for the requested package state.
+//
+extern "C" HRESULT MsiEnginePlanCalculatePackage(
+    __in BURN_PACKAGE* pPackage,
+    __in BURN_VARIABLES* pVariables,
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __out BOOL* pfBARequestedCache
+    )
+{
+    Trace(REPORT_STANDARD, "Planning MSI package 0x%p", pPackage);
+
+    HRESULT hr = S_OK;
+    DWORD64 qwVersion = pPackage->Msi.qwVersion;
+    DWORD64 qwInstalledVersion = pPackage->Msi.qwInstalledVersion;
+    BOOTSTRAPPER_ACTION_STATE execute = BOOTSTRAPPER_ACTION_STATE_NONE;
+    BOOTSTRAPPER_ACTION_STATE rollback = BOOTSTRAPPER_ACTION_STATE_NONE;
+    BOOL fFeatureActionDelta = FALSE;
+    BOOL fRollbackFeatureActionDelta = FALSE;
+    BOOL fBARequestedCache = FALSE;
+
+    if (pPackage->Msi.cFeatures)
+    {
+        // If the package is present and we're repairing it.
+        BOOL fRepairingPackage = (BOOTSTRAPPER_PACKAGE_STATE_CACHED < pPackage->currentState && BOOTSTRAPPER_REQUEST_STATE_REPAIR == pPackage->requested);
+
+        LogId(REPORT_STANDARD, MSG_PLAN_MSI_FEATURES, pPackage->Msi.cFeatures, pPackage->sczId);
+
+        // plan features
+        for (DWORD i = 0; i < pPackage->Msi.cFeatures; ++i)
+        {
+            BURN_MSIFEATURE* pFeature = &pPackage->Msi.rgFeatures[i];
+            BOOTSTRAPPER_FEATURE_STATE defaultFeatureRequestedState = BOOTSTRAPPER_FEATURE_STATE_UNKNOWN;
+            BOOTSTRAPPER_FEATURE_STATE featureRequestedState = BOOTSTRAPPER_FEATURE_STATE_UNKNOWN;
+            BOOTSTRAPPER_FEATURE_STATE featureExpectedState = BOOTSTRAPPER_FEATURE_STATE_UNKNOWN;
+
+            // Evaluate feature conditions.
+            hr = EvaluateActionStateConditions(pVariables, pFeature->sczAddLocalCondition, pFeature->sczAddSourceCondition, pFeature->sczAdvertiseCondition, &defaultFeatureRequestedState);
+            ExitOnFailure(hr, "Failed to evaluate requested state conditions.");
+
+            hr = EvaluateActionStateConditions(pVariables, pFeature->sczRollbackAddLocalCondition, pFeature->sczRollbackAddSourceCondition, pFeature->sczRollbackAdvertiseCondition, &featureExpectedState);
+            ExitOnFailure(hr, "Failed to evaluate expected state conditions.");
+
+            // Remember the default feature requested state so the engine doesn't get blamed for planning the wrong thing if the BA changes it.
+            featureRequestedState = defaultFeatureRequestedState;
+
+            // Send plan MSI feature message to BA.
+            hr = UserExperienceOnPlanMsiFeature(pUserExperience, pPackage->sczId, pFeature->sczId, &featureRequestedState);
+            ExitOnRootFailure(hr, "BA aborted plan MSI feature.");
+
+            // Calculate feature actions.
+            hr = CalculateFeatureAction(pFeature->currentState, featureRequestedState, fRepairingPackage, &pFeature->execute, &fFeatureActionDelta);
+            ExitOnFailure(hr, "Failed to calculate execute feature state.");
+
+            hr = CalculateFeatureAction(featureRequestedState, BOOTSTRAPPER_FEATURE_ACTION_NONE == pFeature->execute ? featureExpectedState : pFeature->currentState, FALSE, &pFeature->rollback, &fRollbackFeatureActionDelta);
+            ExitOnFailure(hr, "Failed to calculate rollback feature state.");
+
+            LogId(REPORT_STANDARD, MSG_PLANNED_MSI_FEATURE, pFeature->sczId, LoggingMsiFeatureStateToString(pFeature->currentState), LoggingMsiFeatureStateToString(defaultFeatureRequestedState), LoggingMsiFeatureStateToString(featureRequestedState), LoggingMsiFeatureActionToString(pFeature->execute), LoggingMsiFeatureActionToString(pFeature->rollback));
+        }
+    }
+
+    // execute action
+    switch (pPackage->currentState)
+    {
+    case BOOTSTRAPPER_PACKAGE_STATE_PRESENT: __fallthrough;
+    case BOOTSTRAPPER_PACKAGE_STATE_SUPERSEDED:
+        if (BOOTSTRAPPER_REQUEST_STATE_PRESENT == pPackage->requested || BOOTSTRAPPER_REQUEST_STATE_REPAIR == pPackage->requested)
+        {
+            // Take a look at the version and determine if this is a potential
+            // minor upgrade (same ProductCode newer ProductVersion), otherwise,
+            // there is a newer version so no work necessary.
+            if (qwVersion > qwInstalledVersion)
+            {
+                execute = BOOTSTRAPPER_ACTION_STATE_MINOR_UPGRADE;
+            }
+            else if (BOOTSTRAPPER_REQUEST_STATE_REPAIR == pPackage->requested)
+            {
+                execute = BOOTSTRAPPER_ACTION_STATE_REPAIR;
+            }
+            else
+            {
+                execute = fFeatureActionDelta ? BOOTSTRAPPER_ACTION_STATE_MODIFY : BOOTSTRAPPER_ACTION_STATE_NONE;
+            }
+        }
+        else if ((BOOTSTRAPPER_REQUEST_STATE_ABSENT == pPackage->requested || BOOTSTRAPPER_REQUEST_STATE_CACHE == pPackage->requested) &&
+                 pPackage->fUninstallable) // removing a package that can be removed.
+        {
+            execute = BOOTSTRAPPER_ACTION_STATE_UNINSTALL;
+        }
+        else if (BOOTSTRAPPER_REQUEST_STATE_FORCE_ABSENT == pPackage->requested)
+        {
+            execute = BOOTSTRAPPER_ACTION_STATE_UNINSTALL;
+        }
+        else
+        {
+            execute = BOOTSTRAPPER_ACTION_STATE_NONE;
+        }
+        break;
+
+    case BOOTSTRAPPER_PACKAGE_STATE_CACHED:
+        switch (pPackage->requested)
+        {
+        case BOOTSTRAPPER_REQUEST_STATE_PRESENT: __fallthrough;
+        case BOOTSTRAPPER_REQUEST_STATE_REPAIR:
+            execute = BOOTSTRAPPER_ACTION_STATE_INSTALL;
+            break;
+
+        default:
+            execute = BOOTSTRAPPER_ACTION_STATE_NONE;
+            break;
+        }
+        break;
+
+    case BOOTSTRAPPER_PACKAGE_STATE_OBSOLETE: __fallthrough;
+    case BOOTSTRAPPER_PACKAGE_STATE_ABSENT:
+        switch (pPackage->requested)
+        {
+        case BOOTSTRAPPER_REQUEST_STATE_PRESENT: __fallthrough;
+        case BOOTSTRAPPER_REQUEST_STATE_REPAIR:
+            execute = BOOTSTRAPPER_ACTION_STATE_INSTALL;
+            break;
+
+        case BOOTSTRAPPER_REQUEST_STATE_CACHE:
+            execute = BOOTSTRAPPER_ACTION_STATE_NONE;
+            fBARequestedCache = TRUE;
+            break;
+
+        default:
+            execute = BOOTSTRAPPER_ACTION_STATE_NONE;
+            break;
+        }
+        break;
+
+    default:
+        hr = E_INVALIDARG;
+        ExitOnRootFailure(hr, "Invalid package current state result encountered during plan: %d", pPackage->currentState);
+    }
+
+    // Calculate the rollback action if there is an execute action.
+    if (BOOTSTRAPPER_ACTION_STATE_NONE != execute)
+    {
+        switch (BOOTSTRAPPER_PACKAGE_STATE_UNKNOWN != pPackage->expected ? pPackage->expected : pPackage->currentState)
+        {
+        case BOOTSTRAPPER_PACKAGE_STATE_PRESENT: __fallthrough;
+        case BOOTSTRAPPER_PACKAGE_STATE_SUPERSEDED:
+            switch (pPackage->requested)
+            {
+            case BOOTSTRAPPER_REQUEST_STATE_PRESENT:
+                rollback = fRollbackFeatureActionDelta ? BOOTSTRAPPER_ACTION_STATE_MODIFY : BOOTSTRAPPER_ACTION_STATE_NONE;
+                break;
+            case BOOTSTRAPPER_REQUEST_STATE_REPAIR:
+                rollback = BOOTSTRAPPER_ACTION_STATE_NONE;
+                break;
+            case BOOTSTRAPPER_REQUEST_STATE_FORCE_ABSENT: __fallthrough;
+            case BOOTSTRAPPER_REQUEST_STATE_ABSENT:
+                rollback = BOOTSTRAPPER_ACTION_STATE_INSTALL;
+                break;
+            default:
+                rollback = BOOTSTRAPPER_ACTION_STATE_NONE;
+                break;
+            }
+            break;
+
+        case BOOTSTRAPPER_PACKAGE_STATE_OBSOLETE: __fallthrough;
+        case BOOTSTRAPPER_PACKAGE_STATE_ABSENT: __fallthrough;
+        case BOOTSTRAPPER_PACKAGE_STATE_CACHED:
+            // If we requested to put the package on the machine then remove the package during rollback
+            // if the package is uninstallable.
+            if ((BOOTSTRAPPER_REQUEST_STATE_PRESENT == pPackage->requested || BOOTSTRAPPER_REQUEST_STATE_REPAIR == pPackage->requested) &&
+                pPackage->fUninstallable)
+            {
+                rollback = BOOTSTRAPPER_ACTION_STATE_UNINSTALL;
+            }
+            else
+            {
+                rollback = BOOTSTRAPPER_ACTION_STATE_NONE;
+            }
+            break;
+
+        default:
+            hr = E_INVALIDARG;
+            ExitOnRootFailure(hr, "Invalid package detection result encountered.");
+        }
+    }
+
+    // return values
+    pPackage->execute = execute;
+    pPackage->rollback = rollback;
+
+    if (pfBARequestedCache)
+    {
+        *pfBARequestedCache = fBARequestedCache;
+    }
+
+LExit:
+    return hr;
+}
+
+//
+// PlanAdd - adds the calculated execute and rollback actions for the package.
+//
+extern "C" HRESULT MsiEnginePlanAddPackage(
+    __in BOOTSTRAPPER_DISPLAY display,
+    __in BURN_PACKAGE* pPackage,
+    __in BURN_PLAN* pPlan,
+    __in BURN_LOGGING* pLog,
+    __in BURN_VARIABLES* pVariables,
+    __in_opt HANDLE hCacheEvent,
+    __in BOOL fPlanPackageCacheRollback
+    )
+{
+    HRESULT hr = S_OK;
+    BURN_EXECUTE_ACTION* pAction = NULL;
+    BOOTSTRAPPER_FEATURE_ACTION* rgFeatureActions = NULL;
+    BOOTSTRAPPER_FEATURE_ACTION* rgRollbackFeatureActions = NULL;
+
+    if (pPackage->Msi.cFeatures)
+    {
+        // Allocate and populate array for feature actions.
+        rgFeatureActions = (BOOTSTRAPPER_FEATURE_ACTION*)MemAlloc(sizeof(BOOTSTRAPPER_FEATURE_ACTION) * pPackage->Msi.cFeatures, TRUE);
+        ExitOnNull(rgFeatureActions, hr, E_OUTOFMEMORY, "Failed to allocate memory for feature actions.");
+
+        rgRollbackFeatureActions = (BOOTSTRAPPER_FEATURE_ACTION*)MemAlloc(sizeof(BOOTSTRAPPER_FEATURE_ACTION) * pPackage->Msi.cFeatures, TRUE);
+        ExitOnNull(rgRollbackFeatureActions, hr, E_OUTOFMEMORY, "Failed to allocate memory for rollback feature actions.");
+
+        for (DWORD i = 0; i < pPackage->Msi.cFeatures; ++i)
+        {
+            BURN_MSIFEATURE* pFeature = &pPackage->Msi.rgFeatures[i];
+
+            // calculate feature actions
+            rgFeatureActions[i] = pFeature->execute;
+            rgRollbackFeatureActions[i] = pFeature->rollback;
+        }
+    }
+
+    // add wait for cache
+    if (hCacheEvent)
+    {
+        hr = PlanExecuteCacheSyncAndRollback(pPlan, pPackage, hCacheEvent, fPlanPackageCacheRollback);
+        ExitOnFailure(hr, "Failed to plan package cache syncpoint");
+    }
+
+    hr = DependencyPlanPackage(NULL, pPackage, pPlan);
+    ExitOnFailure(hr, "Failed to plan package dependency actions.");
+
+    // add rollback action
+    if (BOOTSTRAPPER_ACTION_STATE_NONE != pPackage->rollback)
+    {
+        hr = PlanAppendRollbackAction(pPlan, &pAction);
+        ExitOnFailure(hr, "Failed to append rollback action.");
+
+        pAction->type = BURN_EXECUTE_ACTION_TYPE_MSI_PACKAGE;
+        pAction->msiPackage.pPackage = pPackage;
+        pAction->msiPackage.action = pPackage->rollback;
+        pAction->msiPackage.uiLevel = MsiEngineCalculateInstallUiLevel(pPackage->Msi.fDisplayInternalUI, display, pAction->msiPackage.action);
+        pAction->msiPackage.rgFeatures = rgRollbackFeatureActions;
+        rgRollbackFeatureActions = NULL;
+
+        LoggingSetPackageVariable(pPackage, NULL, TRUE, pLog, pVariables, &pAction->msiPackage.sczLogPath); // ignore errors.
+        pAction->msiPackage.dwLoggingAttributes = pLog->dwAttributes;
+
+        // Plan a checkpoint between rollback and execute so that we always attempt
+        // rollback in the case that the MSI was not able to rollback itself (e.g.
+        // user pushes cancel after InstallFinalize).
+        hr = PlanExecuteCheckpoint(pPlan);
+        ExitOnFailure(hr, "Failed to append execute checkpoint.");
+    }
+
+    // add execute action
+    if (BOOTSTRAPPER_ACTION_STATE_NONE != pPackage->execute)
+    {
+        hr = PlanAppendExecuteAction(pPlan, &pAction);
+        ExitOnFailure(hr, "Failed to append execute action.");
+
+        pAction->type = BURN_EXECUTE_ACTION_TYPE_MSI_PACKAGE;
+        pAction->msiPackage.pPackage = pPackage;
+        pAction->msiPackage.action = pPackage->execute;
+        pAction->msiPackage.uiLevel = MsiEngineCalculateInstallUiLevel(pPackage->Msi.fDisplayInternalUI, display, pAction->msiPackage.action);
+        pAction->msiPackage.rgFeatures = rgFeatureActions;
+        rgFeatureActions = NULL;
+
+        LoggingSetPackageVariable(pPackage, NULL, FALSE, pLog, pVariables, &pAction->msiPackage.sczLogPath); // ignore errors.
+        pAction->msiPackage.dwLoggingAttributes = pLog->dwAttributes;
+    }
+
+    // Update any slipstream patches' state.
+    for (DWORD i = 0; i < pPackage->Msi.cSlipstreamMspPackages; ++i)
+    {
+        BURN_PACKAGE* pMspPackage = pPackage->Msi.rgpSlipstreamMspPackages[i];
+        AssertSz(BURN_PACKAGE_TYPE_MSP == pMspPackage->type, "Only MSP packages can be slipstream patches.");
+
+        MspEngineSlipstreamUpdateState(pMspPackage, pPackage->execute, pPackage->rollback);
+    }
+
+LExit:
+    ReleaseMem(rgFeatureActions);
+    ReleaseMem(rgRollbackFeatureActions);
+
+    return hr;
+}
+
+extern "C" HRESULT MsiEngineAddCompatiblePackage(
+    __in BURN_PACKAGES* pPackages,
+    __in const BURN_PACKAGE* pPackage,
+    __out_opt BURN_PACKAGE** ppCompatiblePackage
+    )
+{
+    Assert(BURN_PACKAGE_TYPE_MSI == pPackage->type);
+
+    HRESULT hr = S_OK;
+    BURN_PACKAGE* pCompatiblePackage = NULL;
+    LPWSTR sczInstalledVersion = NULL;
+
+    // Allocate enough memory all at once so pointers to packages within
+    // aren't invalidated if we otherwise reallocated.
+    hr = PackageEnsureCompatiblePackagesArray(pPackages);
+    ExitOnFailure(hr, "Failed to allocate memory for compatible MSI package.");
+
+    pCompatiblePackage = pPackages->rgCompatiblePackages + pPackages->cCompatiblePackages;
+    ++pPackages->cCompatiblePackages;
+
+    pCompatiblePackage->type = BURN_PACKAGE_TYPE_MSI;
+
+    // Read in the compatible ProductCode if not already available.
+    if (pPackage->Msi.sczInstalledProductCode)
+    {
+        hr = StrAllocString(&pCompatiblePackage->Msi.sczProductCode, pPackage->Msi.sczInstalledProductCode, 0);
+        ExitOnFailure(hr, "Failed to copy installed ProductCode to compatible package.");
+    }
+    else
+    {
+        hr = DependencyDetectProviderKeyPackageId(pPackage, NULL, &pCompatiblePackage->Msi.sczProductCode);
+        ExitOnFailure(hr, "Failed to detect compatible package from provider key.");
+    }
+
+    // Read in the compatible ProductVersion if not already available.
+    if (pPackage->Msi.qwInstalledVersion)
+    {
+        pCompatiblePackage->Msi.qwVersion = pPackage->Msi.qwInstalledVersion;
+
+        hr = FileVersionToStringEx(pCompatiblePackage->Msi.qwVersion, &sczInstalledVersion);
+        ExitOnFailure(hr, "Failed to format version number string.");
+    }
+    else
+    {
+        hr = WiuGetProductInfoEx(pCompatiblePackage->Msi.sczProductCode, NULL, pPackage->fPerMachine ? MSIINSTALLCONTEXT_MACHINE : MSIINSTALLCONTEXT_USERUNMANAGED, INSTALLPROPERTY_VERSIONSTRING, &sczInstalledVersion);
+        ExitOnFailure(hr, "Failed to read version from compatible package.");
+
+        hr = FileVersionFromStringEx(sczInstalledVersion, 0, &pCompatiblePackage->Msi.qwVersion);
+        ExitOnFailure(hr, "Failed to convert version: %ls to DWORD64 for ProductCode: %ls", sczInstalledVersion, pCompatiblePackage->Msi.sczProductCode);
+    }
+
+    // For now, copy enough information to support uninstalling the newer, compatible package.
+    hr = StrAllocString(&pCompatiblePackage->sczId, pCompatiblePackage->Msi.sczProductCode, 0);
+    ExitOnFailure(hr, "Failed to copy installed ProductCode as compatible package ID.");
+
+    pCompatiblePackage->fPerMachine = pPackage->fPerMachine;
+    pCompatiblePackage->fUninstallable = pPackage->fUninstallable;
+    pCompatiblePackage->cacheType = pPackage->cacheType;
+
+    // Removing compatible packages is best effort.
+    pCompatiblePackage->fVital = FALSE;
+
+    // Format a suitable log path variable from the original package.
+    hr = StrAllocFormatted(&pCompatiblePackage->sczLogPathVariable, L"%ls_Compatible", pPackage->sczLogPathVariable);
+    ExitOnFailure(hr, "Failed to format log path variable for compatible package.");
+
+    // Use the default cache ID generation from the binder.
+    hr = StrAllocFormatted(&pCompatiblePackage->sczCacheId, L"%lsv%ls", pCompatiblePackage->sczId, sczInstalledVersion);
+    ExitOnFailure(hr, "Failed to format cache ID for compatible package.");
+
+    pCompatiblePackage->currentState = BOOTSTRAPPER_PACKAGE_STATE_PRESENT;
+    pCompatiblePackage->cache = BURN_CACHE_STATE_PARTIAL; // Cannot know if it's complete or not.
+
+    // Copy all the providers to ensure no dependents.
+    if (pPackage->cDependencyProviders)
+    {
+        pCompatiblePackage->rgDependencyProviders = (BURN_DEPENDENCY_PROVIDER*)MemAlloc(sizeof(BURN_DEPENDENCY_PROVIDER) * pPackage->cDependencyProviders, TRUE);
+        ExitOnNull(pCompatiblePackage->rgDependencyProviders, hr, E_OUTOFMEMORY, "Failed to allocate for compatible package providers.");
+
+        for (DWORD i = 0; i < pPackage->cDependencyProviders; ++i)
+        {
+            BURN_DEPENDENCY_PROVIDER* pProvider = pPackage->rgDependencyProviders + i;
+            BURN_DEPENDENCY_PROVIDER* pCompatibleProvider = pCompatiblePackage->rgDependencyProviders + i;
+
+            // Only need to copy the key for uninstall.
+            hr = StrAllocString(&pCompatibleProvider->sczKey, pProvider->sczKey, 0);
+            ExitOnFailure(hr, "Failed to copy the compatible provider key.");
+
+            // Assume the package version is the same as the provider version.
+            hr = StrAllocString(&pCompatibleProvider->sczVersion, sczInstalledVersion, 0);
+            ExitOnFailure(hr, "Failed to copy the compatible provider version.");
+
+            // Assume provider keys are similarly authored for this package.
+            pCompatibleProvider->fImported = pProvider->fImported;
+        }
+
+        pCompatiblePackage->cDependencyProviders = pPackage->cDependencyProviders;
+    }
+
+    pCompatiblePackage->type = BURN_PACKAGE_TYPE_MSI;
+    pCompatiblePackage->Msi.fDisplayInternalUI = pPackage->Msi.fDisplayInternalUI;
+
+    if (ppCompatiblePackage)
+    {
+        *ppCompatiblePackage = pCompatiblePackage;
+    }
+
+LExit:
+    ReleaseStr(sczInstalledVersion);
+
+    return hr;
+}
+
+extern "C" HRESULT MsiEngineExecutePackage(
+    __in_opt HWND hwndParent,
+    __in BURN_EXECUTE_ACTION* pExecuteAction,
+    __in BURN_VARIABLES* pVariables,
+    __in BOOL fRollback,
+    __in PFN_MSIEXECUTEMESSAGEHANDLER pfnMessageHandler,
+    __in LPVOID pvContext,
+    __out BOOTSTRAPPER_APPLY_RESTART* pRestart
+    )
+{
+    HRESULT hr = S_OK;
+    WIU_MSI_EXECUTE_CONTEXT context = { };
+    WIU_RESTART restart = WIU_RESTART_NONE;
+
+    LPWSTR sczInstalledVersion = NULL;
+    LPWSTR sczCachedDirectory = NULL;
+    LPWSTR sczMsiPath = NULL;
+    LPWSTR sczProperties = NULL;
+    LPWSTR sczObfuscatedProperties = NULL;
+
+    // During rollback, if the package is already in the rollback state we expect don't
+    // touch it again.
+    if (fRollback)
+    {
+        if (BOOTSTRAPPER_ACTION_STATE_UNINSTALL == pExecuteAction->msiPackage.action)
+        {
+            hr = WiuGetProductInfoEx(pExecuteAction->msiPackage.pPackage->Msi.sczProductCode, NULL, pExecuteAction->msiPackage.pPackage->fPerMachine ? MSIINSTALLCONTEXT_MACHINE : MSIINSTALLCONTEXT_USERUNMANAGED, INSTALLPROPERTY_VERSIONSTRING, &sczInstalledVersion);
+            if (FAILED(hr))  // package not present.
+            {
+                LogId(REPORT_STANDARD, MSG_ROLLBACK_PACKAGE_SKIPPED, pExecuteAction->msiPackage.pPackage->sczId, LoggingActionStateToString(pExecuteAction->msiPackage.action), LoggingPackageStateToString(BOOTSTRAPPER_PACKAGE_STATE_ABSENT));
+
+                hr = S_OK;
+                ExitFunction();
+            }
+        }
+        else if (BOOTSTRAPPER_ACTION_STATE_INSTALL == pExecuteAction->msiPackage.action)
+        {
+            hr = WiuGetProductInfoEx(pExecuteAction->msiPackage.pPackage->Msi.sczProductCode, NULL, pExecuteAction->msiPackage.pPackage->fPerMachine ? MSIINSTALLCONTEXT_MACHINE : MSIINSTALLCONTEXT_USERUNMANAGED, INSTALLPROPERTY_VERSIONSTRING, &sczInstalledVersion);
+            if (SUCCEEDED(hr))  // package present.
+            {
+                LogId(REPORT_STANDARD, MSG_ROLLBACK_PACKAGE_SKIPPED, pExecuteAction->msiPackage.pPackage->sczId, LoggingActionStateToString(pExecuteAction->msiPackage.action), LoggingPackageStateToString(BOOTSTRAPPER_PACKAGE_STATE_PRESENT));
+
+                hr = S_OK;
+                ExitFunction();
+            }
+
+            hr = S_OK;
+        }
+    }
+
+    // Default to "verbose" logging and set extra debug mode only if explicitly required.
+    DWORD dwLogMode = WIU_LOG_DEFAULT | INSTALLLOGMODE_VERBOSE;
+
+    if (pExecuteAction->msiPackage.dwLoggingAttributes & BURN_LOGGING_ATTRIBUTE_EXTRADEBUG)
+    {
+        dwLogMode |= INSTALLLOGMODE_EXTRADEBUG;
+    }
+
+    if (BOOTSTRAPPER_ACTION_STATE_UNINSTALL != pExecuteAction->msiPackage.action)
+    {
+        // get cached MSI path
+        hr = CacheGetCompletedPath(pExecuteAction->msiPackage.pPackage->fPerMachine, pExecuteAction->msiPackage.pPackage->sczCacheId, &sczCachedDirectory);
+        ExitOnFailure(hr, "Failed to get cached path for package: %ls", pExecuteAction->msiPackage.pPackage->sczId);
+
+        // Best effort to set the execute package cache folder variable.
+        VariableSetString(pVariables, BURN_BUNDLE_EXECUTE_PACKAGE_CACHE_FOLDER, sczCachedDirectory, TRUE);
+
+        hr = PathConcat(sczCachedDirectory, pExecuteAction->msiPackage.pPackage->rgPayloads[0].pPayload->sczFilePath, &sczMsiPath);
+        ExitOnFailure(hr, "Failed to build MSI path.");
+    }
+
+    // Best effort to set the execute package action variable.
+    VariableSetNumeric(pVariables, BURN_BUNDLE_EXECUTE_PACKAGE_ACTION, pExecuteAction->msiPackage.action, TRUE);
+    
+    // Wire up the external UI handler and logging.
+    hr = WiuInitializeExternalUI(pfnMessageHandler, pExecuteAction->msiPackage.uiLevel, hwndParent, pvContext, fRollback, &context);
+    ExitOnFailure(hr, "Failed to initialize external UI handler.");
+
+    if (pExecuteAction->msiPackage.sczLogPath && *pExecuteAction->msiPackage.sczLogPath)
+    {
+        hr = WiuEnableLog(dwLogMode, pExecuteAction->msiPackage.sczLogPath, 0);
+        ExitOnFailure(hr, "Failed to enable logging for package: %ls to: %ls", pExecuteAction->msiPackage.pPackage->sczId, pExecuteAction->msiPackage.sczLogPath);
+    }
+
+    // set up properties
+    hr = MsiEngineConcatProperties(pExecuteAction->msiPackage.pPackage->Msi.rgProperties, pExecuteAction->msiPackage.pPackage->Msi.cProperties, pVariables, fRollback, &sczProperties, FALSE);
+    ExitOnFailure(hr, "Failed to add properties to argument string.");
+
+    hr = MsiEngineConcatProperties(pExecuteAction->msiPackage.pPackage->Msi.rgProperties, pExecuteAction->msiPackage.pPackage->Msi.cProperties, pVariables, fRollback, &sczObfuscatedProperties, TRUE);
+    ExitOnFailure(hr, "Failed to add obfuscated properties to argument string.");
+
+    // add feature action properties
+    hr = ConcatFeatureActionProperties(pExecuteAction->msiPackage.pPackage, pExecuteAction->msiPackage.rgFeatures, &sczProperties);
+    ExitOnFailure(hr, "Failed to add feature action properties to argument string.");
+
+    hr = ConcatFeatureActionProperties(pExecuteAction->msiPackage.pPackage, pExecuteAction->msiPackage.rgFeatures, &sczObfuscatedProperties);
+    ExitOnFailure(hr, "Failed to add feature action properties to obfuscated argument string.");
+
+    // add slipstream patch properties
+    hr = ConcatPatchProperty(pExecuteAction->msiPackage.pPackage, pExecuteAction->msiPackage.rgSlipstreamPatches, &sczProperties);
+    ExitOnFailure(hr, "Failed to add patch properties to argument string.");
+
+    hr = ConcatPatchProperty(pExecuteAction->msiPackage.pPackage, pExecuteAction->msiPackage.rgSlipstreamPatches, &sczObfuscatedProperties);
+    ExitOnFailure(hr, "Failed to add patch properties to obfuscated argument string.");
+
+    LogId(REPORT_STANDARD, MSG_APPLYING_PACKAGE, LoggingRollbackOrExecute(fRollback), pExecuteAction->msiPackage.pPackage->sczId, LoggingActionStateToString(pExecuteAction->msiPackage.action), sczMsiPath, sczObfuscatedProperties ? sczObfuscatedProperties : L"");
+
+    //
+    // Do the actual action.
+    //
+    switch (pExecuteAction->msiPackage.action)
+    {
+    case BOOTSTRAPPER_ACTION_STATE_ADMIN_INSTALL:
+        hr = StrAllocConcatSecure(&sczProperties, L" ACTION=ADMIN", 0);
+        ExitOnFailure(hr, "Failed to add ADMIN property on admin install.");
+         __fallthrough;
+
+    case BOOTSTRAPPER_ACTION_STATE_MAJOR_UPGRADE: __fallthrough;
+    case BOOTSTRAPPER_ACTION_STATE_INSTALL:
+        hr = StrAllocConcatSecure(&sczProperties, L" REBOOT=ReallySuppress", 0);
+        ExitOnFailure(hr, "Failed to add reboot suppression property on install.");
+
+        hr = WiuInstallProduct(sczMsiPath, sczProperties, &restart);
+        ExitOnFailure(hr, "Failed to install MSI package.");
+
+        RegisterSourceDirectory(pExecuteAction->msiPackage.pPackage, sczMsiPath);
+        break;
+
+    case BOOTSTRAPPER_ACTION_STATE_MINOR_UPGRADE:
+        // If feature selection is not enabled, then reinstall the existing features to ensure they get
+        // updated.
+        if (0 == pExecuteAction->msiPackage.pPackage->Msi.cFeatures)
+        {
+            hr = StrAllocConcatSecure(&sczProperties, L" REINSTALL=ALL", 0);
+            ExitOnFailure(hr, "Failed to add reinstall all property on minor upgrade.");
+        }
+
+        hr = StrAllocConcatSecure(&sczProperties, L" REINSTALLMODE=\"vomus\" REBOOT=ReallySuppress", 0);
+        ExitOnFailure(hr, "Failed to add reinstall mode and reboot suppression properties on minor upgrade.");
+
+        hr = WiuInstallProduct(sczMsiPath, sczProperties, &restart);
+        ExitOnFailure(hr, "Failed to perform minor upgrade of MSI package.");
+
+        RegisterSourceDirectory(pExecuteAction->msiPackage.pPackage, sczMsiPath);
+        break;
+
+    case BOOTSTRAPPER_ACTION_STATE_MODIFY: __fallthrough;
+    case BOOTSTRAPPER_ACTION_STATE_REPAIR:
+        {
+        LPCWSTR wzReinstallAll = (BOOTSTRAPPER_ACTION_STATE_MODIFY == pExecuteAction->msiPackage.action ||
+                                  pExecuteAction->msiPackage.pPackage->Msi.cFeatures) ? L"" : L" REINSTALL=ALL";
+        LPCWSTR wzReinstallMode = (BOOTSTRAPPER_ACTION_STATE_MODIFY == pExecuteAction->msiPackage.action) ? L"o" : L"e";
+
+        hr = StrAllocFormattedSecure(&sczProperties, L"%ls%ls REINSTALLMODE=\"cmus%ls\" REBOOT=ReallySuppress", sczProperties ? sczProperties : L"", wzReinstallAll, wzReinstallMode);
+        ExitOnFailure(hr, "Failed to add reinstall mode and reboot suppression properties on repair.");
+        }
+
+        // Ignore all dependencies, since the Burn engine already performed the check.
+        hr = StrAllocFormattedSecure(&sczProperties, L"%ls %ls=ALL", sczProperties, DEPENDENCY_IGNOREDEPENDENCIES);
+        ExitOnFailure(hr, "Failed to add the list of dependencies to ignore to the properties.");
+
+        hr = WiuInstallProduct(sczMsiPath, sczProperties, &restart);
+        ExitOnFailure(hr, "Failed to run maintenance mode for MSI package.");
+        break;
+
+    case BOOTSTRAPPER_ACTION_STATE_UNINSTALL:
+        hr = StrAllocConcatSecure(&sczProperties, L" REBOOT=ReallySuppress", 0);
+        ExitOnFailure(hr, "Failed to add reboot suppression property on uninstall.");
+
+        // Ignore all dependencies, since the Burn engine already performed the check.
+        hr = StrAllocFormattedSecure(&sczProperties, L"%ls %ls=ALL", sczProperties, DEPENDENCY_IGNOREDEPENDENCIES);
+        ExitOnFailure(hr, "Failed to add the list of dependencies to ignore to the properties.");
+
+        hr = WiuConfigureProductEx(pExecuteAction->msiPackage.pPackage->Msi.sczProductCode, INSTALLLEVEL_DEFAULT, INSTALLSTATE_ABSENT, sczProperties, &restart);
+        if (HRESULT_FROM_WIN32(ERROR_UNKNOWN_PRODUCT) == hr)
+        {
+            LogId(REPORT_STANDARD, MSG_ATTEMPTED_UNINSTALL_ABSENT_PACKAGE, pExecuteAction->msiPackage.pPackage->sczId);
+            hr = S_OK;
+        }
+        ExitOnFailure(hr, "Failed to uninstall MSI package.");
+        break;
+    }
+
+LExit:
+    WiuUninitializeExternalUI(&context);
+
+    StrSecureZeroFreeString(sczProperties);
+    ReleaseStr(sczObfuscatedProperties);
+    ReleaseStr(sczMsiPath);
+    ReleaseStr(sczCachedDirectory);
+    ReleaseStr(sczInstalledVersion);
+
+    switch (restart)
+    {
+        case WIU_RESTART_NONE:
+            *pRestart = BOOTSTRAPPER_APPLY_RESTART_NONE;
+            break;
+
+        case WIU_RESTART_REQUIRED:
+            *pRestart = BOOTSTRAPPER_APPLY_RESTART_REQUIRED;
+            break;
+
+        case WIU_RESTART_INITIATED:
+            *pRestart = BOOTSTRAPPER_APPLY_RESTART_INITIATED;
+            break;
+    }
+
+    // Best effort to clear the execute package cache folder and action variables.
+    VariableSetString(pVariables, BURN_BUNDLE_EXECUTE_PACKAGE_CACHE_FOLDER, NULL, TRUE);
+    VariableSetString(pVariables, BURN_BUNDLE_EXECUTE_PACKAGE_ACTION, NULL, TRUE);
+
+    return hr;
+}
+
+// The contents of psczProperties may be sensitive, should keep encrypted and SecureZeroFree.
+extern "C" HRESULT MsiEngineConcatProperties(
+    __in_ecount(cProperties) BURN_MSIPROPERTY* rgProperties,
+    __in DWORD cProperties,
+    __in BURN_VARIABLES* pVariables,
+    __in BOOL fRollback,
+    __deref_out_z LPWSTR* psczProperties,
+    __in BOOL fObfuscateHiddenVariables
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR sczValue = NULL;
+    LPWSTR sczEscapedValue = NULL;
+    LPWSTR sczProperty = NULL;
+
+    for (DWORD i = 0; i < cProperties; ++i)
+    {
+        BURN_MSIPROPERTY* pProperty = &rgProperties[i];
+
+        if (pProperty->sczCondition && *pProperty->sczCondition)
+        {
+            BOOL fCondition = FALSE;
+
+            hr = ConditionEvaluate(pVariables, pProperty->sczCondition, &fCondition);
+            if (FAILED(hr) || !fCondition)
+            {
+                LogId(REPORT_VERBOSE, MSG_MSI_PROPERTY_CONDITION_FAILED, pProperty->sczId, pProperty->sczCondition, LoggingTrueFalseToString(fCondition));
+                continue;
+            }
+        }
+
+        // format property value
+        if (fObfuscateHiddenVariables)
+        {
+            hr = VariableFormatStringObfuscated(pVariables, (fRollback && pProperty->sczRollbackValue) ? pProperty->sczRollbackValue : pProperty->sczValue, &sczValue, NULL);
+        }
+        else
+        {
+            hr = VariableFormatString(pVariables, (fRollback && pProperty->sczRollbackValue) ? pProperty->sczRollbackValue : pProperty->sczValue, &sczValue, NULL);
+            ExitOnFailure(hr, "Failed to format property value.");
+        }
+        ExitOnFailure(hr, "Failed to format property value.");
+
+        // escape property value
+        hr = EscapePropertyArgumentString(sczValue, &sczEscapedValue, !fObfuscateHiddenVariables);
+        ExitOnFailure(hr, "Failed to escape string.");
+
+        // build part
+        hr = VariableStrAllocFormatted(!fObfuscateHiddenVariables, &sczProperty, L" %s%=\"%s\"", pProperty->sczId, sczEscapedValue);
+        ExitOnFailure(hr, "Failed to format property string part.");
+
+        // append to property string
+        hr = VariableStrAllocConcat(!fObfuscateHiddenVariables, psczProperties, sczProperty, 0);
+        ExitOnFailure(hr, "Failed to append property string part.");
+    }
+
+LExit:
+    StrSecureZeroFreeString(sczValue);
+    StrSecureZeroFreeString(sczEscapedValue);
+    StrSecureZeroFreeString(sczProperty);
+    return hr;
+}
+
+extern "C" INSTALLUILEVEL MsiEngineCalculateInstallUiLevel(
+    __in BOOL fDisplayInternalUI,
+    __in BOOTSTRAPPER_DISPLAY display,
+    __in BOOTSTRAPPER_ACTION_STATE actionState
+    )
+{
+    // Assume there will be no internal UI displayed.
+    INSTALLUILEVEL uiLevel = static_cast<INSTALLUILEVEL>(INSTALLUILEVEL_NONE | INSTALLUILEVEL_SOURCERESONLY);
+
+    // suppress internal UI during uninstall to mimic ARP and "msiexec /x" behavior
+    if (fDisplayInternalUI && BOOTSTRAPPER_ACTION_STATE_UNINSTALL != actionState && BOOTSTRAPPER_ACTION_STATE_REPAIR != actionState)
+    {
+        switch (display)
+        {
+        case BOOTSTRAPPER_DISPLAY_FULL:
+            uiLevel = INSTALLUILEVEL_FULL;
+            break;
+
+        case BOOTSTRAPPER_DISPLAY_PASSIVE:
+            uiLevel = INSTALLUILEVEL_REDUCED;
+            break;
+        }
+    }
+
+    return uiLevel;
+}
+
+
+// internal helper functions
+
+static HRESULT ParseRelatedMsiFromXml(
+    __in IXMLDOMNode* pixnRelatedMsi,
+    __in BURN_RELATED_MSI* pRelatedMsi
+    )
+{
+    HRESULT hr = S_OK;
+    IXMLDOMNodeList* pixnNodes = NULL;
+    IXMLDOMNode* pixnNode = NULL;
+    DWORD cNodes = 0;
+    LPWSTR scz = NULL;
+
+    // @Id
+    hr = XmlGetAttributeEx(pixnRelatedMsi, L"Id", &pRelatedMsi->sczUpgradeCode);
+    ExitOnFailure(hr, "Failed to get @Id.");
+
+    // @MinVersion
+    hr = XmlGetAttributeEx(pixnRelatedMsi, L"MinVersion", &scz);
+    if (E_NOTFOUND != hr)
+    {
+        ExitOnFailure(hr, "Failed to get @MinVersion.");
+
+        hr = FileVersionFromStringEx(scz, 0, &pRelatedMsi->qwMinVersion);
+        ExitOnFailure(hr, "Failed to parse @MinVersion: %ls", scz);
+
+        // flag that we have a min version
+        pRelatedMsi->fMinProvided = TRUE;
+
+        // @MinInclusive
+        hr = XmlGetYesNoAttribute(pixnRelatedMsi, L"MinInclusive", &pRelatedMsi->fMinInclusive);
+        ExitOnFailure(hr, "Failed to get @MinInclusive.");
+    }
+
+    // @MaxVersion
+    hr = XmlGetAttributeEx(pixnRelatedMsi, L"MaxVersion", &scz);
+    if (E_NOTFOUND != hr)
+    {
+        ExitOnFailure(hr, "Failed to get @MaxVersion.");
+
+        hr = FileVersionFromStringEx(scz, 0, &pRelatedMsi->qwMaxVersion);
+        ExitOnFailure(hr, "Failed to parse @MaxVersion: %ls", scz);
+
+        // flag that we have a max version
+        pRelatedMsi->fMaxProvided = TRUE;
+
+        // @MaxInclusive
+        hr = XmlGetYesNoAttribute(pixnRelatedMsi, L"MaxInclusive", &pRelatedMsi->fMaxInclusive);
+        ExitOnFailure(hr, "Failed to get @MaxInclusive.");
+    }
+
+    // @OnlyDetect
+    hr = XmlGetYesNoAttribute(pixnRelatedMsi, L"OnlyDetect", &pRelatedMsi->fOnlyDetect);
+    ExitOnFailure(hr, "Failed to get @OnlyDetect.");
+
+    // select language nodes
+    hr = XmlSelectNodes(pixnRelatedMsi, L"Language", &pixnNodes);
+    ExitOnFailure(hr, "Failed to select language nodes.");
+
+    // get language node count
+    hr = pixnNodes->get_length((long*)&cNodes);
+    ExitOnFailure(hr, "Failed to get language node count.");
+
+    if (cNodes)
+    {
+        // @LangInclusive
+        hr = XmlGetYesNoAttribute(pixnRelatedMsi, L"LangInclusive", &pRelatedMsi->fLangInclusive);
+        ExitOnFailure(hr, "Failed to get @LangInclusive.");
+
+        // allocate memory for language IDs
+        pRelatedMsi->rgdwLanguages = (DWORD*)MemAlloc(sizeof(DWORD) * cNodes, TRUE);
+        ExitOnNull(pRelatedMsi->rgdwLanguages, hr, E_OUTOFMEMORY, "Failed to allocate memory for language IDs.");
+
+        pRelatedMsi->cLanguages = cNodes;
+
+        // parse language elements
+        for (DWORD i = 0; i < cNodes; ++i)
+        {
+            hr = XmlNextElement(pixnNodes, &pixnNode, NULL);
+            ExitOnFailure(hr, "Failed to get next node.");
+
+            // @Id
+            hr = XmlGetAttributeNumber(pixnNode, L"Id", &pRelatedMsi->rgdwLanguages[i]);
+            ExitOnFailure(hr, "Failed to get Language/@Id.");
+
+            // prepare next iteration
+            ReleaseNullObject(pixnNode);
+        }
+    }
+
+    hr = S_OK;
+
+LExit:
+    ReleaseObject(pixnNodes);
+    ReleaseObject(pixnNode);
+    ReleaseStr(scz);
+
+    return hr;
+}
+
+static HRESULT EvaluateActionStateConditions(
+    __in BURN_VARIABLES* pVariables,
+    __in_z_opt LPCWSTR sczAddLocalCondition,
+    __in_z_opt LPCWSTR sczAddSourceCondition,
+    __in_z_opt LPCWSTR sczAdvertiseCondition,
+    __out BOOTSTRAPPER_FEATURE_STATE* pState
+    )
+{
+    HRESULT hr = S_OK;
+    BOOL fCondition = FALSE;
+
+    // if no condition was set, return no feature state
+    if (!sczAddLocalCondition && !sczAddSourceCondition && !sczAdvertiseCondition)
+    {
+        *pState = BOOTSTRAPPER_FEATURE_STATE_UNKNOWN;
+        ExitFunction();
+    }
+
+    if (sczAddLocalCondition)
+    {
+        hr = ConditionEvaluate(pVariables, sczAddLocalCondition, &fCondition);
+        ExitOnFailure(hr, "Failed to evaluate add local condition.");
+
+        if (fCondition)
+        {
+            *pState = BOOTSTRAPPER_FEATURE_STATE_LOCAL;
+            ExitFunction();
+        }
+    }
+
+    if (sczAddSourceCondition)
+    {
+        hr = ConditionEvaluate(pVariables, sczAddSourceCondition, &fCondition);
+        ExitOnFailure(hr, "Failed to evaluate add source condition.");
+
+        if (fCondition)
+        {
+            *pState = BOOTSTRAPPER_FEATURE_STATE_SOURCE;
+            ExitFunction();
+        }
+    }
+
+    if (sczAdvertiseCondition)
+    {
+        hr = ConditionEvaluate(pVariables, sczAdvertiseCondition, &fCondition);
+        ExitOnFailure(hr, "Failed to evaluate advertise condition.");
+
+        if (fCondition)
+        {
+            *pState = BOOTSTRAPPER_FEATURE_STATE_ADVERTISED;
+            ExitFunction();
+        }
+    }
+
+    // if no condition was true, set to absent
+    *pState = BOOTSTRAPPER_FEATURE_STATE_ABSENT;
+
+LExit:
+    return hr;
+}
+
+static HRESULT CalculateFeatureAction(
+    __in BOOTSTRAPPER_FEATURE_STATE currentState,
+    __in BOOTSTRAPPER_FEATURE_STATE requestedState,
+    __in BOOL fRepair,
+    __out BOOTSTRAPPER_FEATURE_ACTION* pFeatureAction,
+    __inout BOOL* pfDelta
+    )
+{
+    HRESULT hr = S_OK;
+
+    *pFeatureAction = BOOTSTRAPPER_FEATURE_ACTION_NONE;
+    switch (requestedState)
+    {
+    case BOOTSTRAPPER_FEATURE_STATE_UNKNOWN:
+        *pFeatureAction = BOOTSTRAPPER_FEATURE_ACTION_NONE;
+        break;
+
+    case BOOTSTRAPPER_FEATURE_STATE_ABSENT:
+        if (BOOTSTRAPPER_FEATURE_STATE_ABSENT != currentState)
+        {
+            *pFeatureAction = BOOTSTRAPPER_FEATURE_ACTION_REMOVE;
+        }
+        break;
+
+    case BOOTSTRAPPER_FEATURE_STATE_ADVERTISED:
+        if (BOOTSTRAPPER_FEATURE_STATE_ADVERTISED != currentState)
+        {
+            *pFeatureAction = BOOTSTRAPPER_FEATURE_ACTION_ADVERTISE;
+        }
+        else if (fRepair)
+        {
+            *pFeatureAction = BOOTSTRAPPER_FEATURE_ACTION_REINSTALL;
+        }
+        break;
+
+    case BOOTSTRAPPER_FEATURE_STATE_LOCAL:
+        if (BOOTSTRAPPER_FEATURE_STATE_LOCAL != currentState)
+        {
+            *pFeatureAction = BOOTSTRAPPER_FEATURE_ACTION_ADDLOCAL;
+        }
+        else if (fRepair)
+        {
+            *pFeatureAction = BOOTSTRAPPER_FEATURE_ACTION_REINSTALL;
+        }
+        break;
+
+    case BOOTSTRAPPER_FEATURE_STATE_SOURCE:
+        if (BOOTSTRAPPER_FEATURE_STATE_SOURCE != currentState)
+        {
+            *pFeatureAction = BOOTSTRAPPER_FEATURE_ACTION_ADDSOURCE;
+        }
+        else if (fRepair)
+        {
+            *pFeatureAction = BOOTSTRAPPER_FEATURE_ACTION_REINSTALL;
+        }
+        break;
+
+    default:
+        hr = E_UNEXPECTED;
+        ExitOnRootFailure(hr, "Invalid state value.");
+    }
+
+    if (BOOTSTRAPPER_FEATURE_ACTION_NONE != *pFeatureAction)
+    {
+        *pfDelta = TRUE;
+    }
+
+LExit:
+    return hr;
+}
+
+static HRESULT EscapePropertyArgumentString(
+    __in LPCWSTR wzProperty,
+    __inout_z LPWSTR* psczEscapedValue,
+    __in BOOL fZeroOnRealloc
+    )
+{
+    HRESULT hr = S_OK;
+    DWORD cch = 0;
+    DWORD cchEscape = 0;
+    LPCWSTR wzSource = NULL;
+    LPWSTR wzTarget = NULL;
+
+    // count characters to escape
+    wzSource = wzProperty;
+    while (*wzSource)
+    {
+        ++cch;
+        if (L'\"' == *wzSource)
+        {
+            ++cchEscape;
+        }
+        ++wzSource;
+    }
+
+    // allocate target buffer
+    hr = VariableStrAlloc(fZeroOnRealloc, psczEscapedValue, cch + cchEscape + 1); // character count, plus escape character count, plus null terminator
+    ExitOnFailure(hr, "Failed to allocate string buffer.");
+
+    // write to target buffer
+    wzSource = wzProperty;
+    wzTarget = *psczEscapedValue;
+    while (*wzSource)
+    {
+        *wzTarget = *wzSource;
+        if (L'\"' == *wzTarget)
+        {
+            ++wzTarget;
+            *wzTarget = L'\"';
+        }
+
+        ++wzSource;
+        ++wzTarget;
+    }
+
+    *wzTarget = L'\0'; // add null terminator
+
+LExit:
+    return hr;
+}
+
+static HRESULT ConcatFeatureActionProperties(
+    __in BURN_PACKAGE* pPackage,
+    __in BOOTSTRAPPER_FEATURE_ACTION* rgFeatureActions,
+    __inout_z LPWSTR* psczArguments
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR scz = NULL;
+    LPWSTR sczAddLocal = NULL;
+    LPWSTR sczAddSource = NULL;
+    LPWSTR sczAddDefault = NULL;
+    LPWSTR sczReinstall = NULL;
+    LPWSTR sczAdvertise = NULL;
+    LPWSTR sczRemove = NULL;
+
+    // features
+    for (DWORD i = 0; i < pPackage->Msi.cFeatures; ++i)
+    {
+        BURN_MSIFEATURE* pFeature = &pPackage->Msi.rgFeatures[i];
+
+        switch (rgFeatureActions[i])
+        {
+        case BOOTSTRAPPER_FEATURE_ACTION_ADDLOCAL:
+            if (sczAddLocal)
+            {
+                hr = StrAllocConcat(&sczAddLocal, L",", 0);
+                ExitOnFailure(hr, "Failed to concat separator.");
+            }
+            hr = StrAllocConcat(&sczAddLocal, pFeature->sczId, 0);
+            ExitOnFailure(hr, "Failed to concat feature.");
+            break;
+
+        case BOOTSTRAPPER_FEATURE_ACTION_ADDSOURCE:
+            if (sczAddSource)
+            {
+                hr = StrAllocConcat(&sczAddSource, L",", 0);
+                ExitOnFailure(hr, "Failed to concat separator.");
+            }
+            hr = StrAllocConcat(&sczAddSource, pFeature->sczId, 0);
+            ExitOnFailure(hr, "Failed to concat feature.");
+            break;
+
+        case BOOTSTRAPPER_FEATURE_ACTION_ADDDEFAULT:
+            if (sczAddDefault)
+            {
+                hr = StrAllocConcat(&sczAddDefault, L",", 0);
+                ExitOnFailure(hr, "Failed to concat separator.");
+            }
+            hr = StrAllocConcat(&sczAddDefault, pFeature->sczId, 0);
+            ExitOnFailure(hr, "Failed to concat feature.");
+            break;
+
+        case BOOTSTRAPPER_FEATURE_ACTION_REINSTALL:
+            if (sczReinstall)
+            {
+                hr = StrAllocConcat(&sczReinstall, L",", 0);
+                ExitOnFailure(hr, "Failed to concat separator.");
+            }
+            hr = StrAllocConcat(&sczReinstall, pFeature->sczId, 0);
+            ExitOnFailure(hr, "Failed to concat feature.");
+            break;
+
+        case BOOTSTRAPPER_FEATURE_ACTION_ADVERTISE:
+            if (sczAdvertise)
+            {
+                hr = StrAllocConcat(&sczAdvertise, L",", 0);
+                ExitOnFailure(hr, "Failed to concat separator.");
+            }
+            hr = StrAllocConcat(&sczAdvertise, pFeature->sczId, 0);
+            ExitOnFailure(hr, "Failed to concat feature.");
+            break;
+
+        case BOOTSTRAPPER_FEATURE_ACTION_REMOVE:
+            if (sczRemove)
+            {
+                hr = StrAllocConcat(&sczRemove, L",", 0);
+                ExitOnFailure(hr, "Failed to concat separator.");
+            }
+            hr = StrAllocConcat(&sczRemove, pFeature->sczId, 0);
+            ExitOnFailure(hr, "Failed to concat feature.");
+            break;
+        }
+    }
+
+    if (sczAddLocal)
+    {
+        hr = StrAllocFormatted(&scz, L" ADDLOCAL=\"%s\"", sczAddLocal, 0);
+        ExitOnFailure(hr, "Failed to format ADDLOCAL string.");
+
+        hr = StrAllocConcatSecure(psczArguments, scz, 0);
+        ExitOnFailure(hr, "Failed to concat argument string.");
+    }
+
+    if (sczAddSource)
+    {
+        hr = StrAllocFormatted(&scz, L" ADDSOURCE=\"%s\"", sczAddSource, 0);
+        ExitOnFailure(hr, "Failed to format ADDSOURCE string.");
+
+        hr = StrAllocConcatSecure(psczArguments, scz, 0);
+        ExitOnFailure(hr, "Failed to concat argument string.");
+    }
+
+    if (sczAddDefault)
+    {
+        hr = StrAllocFormatted(&scz, L" ADDDEFAULT=\"%s\"", sczAddDefault, 0);
+        ExitOnFailure(hr, "Failed to format ADDDEFAULT string.");
+
+        hr = StrAllocConcatSecure(psczArguments, scz, 0);
+        ExitOnFailure(hr, "Failed to concat argument string.");
+    }
+
+    if (sczReinstall)
+    {
+        hr = StrAllocFormatted(&scz, L" REINSTALL=\"%s\"", sczReinstall, 0);
+        ExitOnFailure(hr, "Failed to format REINSTALL string.");
+
+        hr = StrAllocConcatSecure(psczArguments, scz, 0);
+        ExitOnFailure(hr, "Failed to concat argument string.");
+    }
+
+    if (sczAdvertise)
+    {
+        hr = StrAllocFormatted(&scz, L" ADVERTISE=\"%s\"", sczAdvertise, 0);
+        ExitOnFailure(hr, "Failed to format ADVERTISE string.");
+
+        hr = StrAllocConcatSecure(psczArguments, scz, 0);
+        ExitOnFailure(hr, "Failed to concat argument string.");
+    }
+
+    if (sczRemove)
+    {
+        hr = StrAllocFormatted(&scz, L" REMOVE=\"%s\"", sczRemove, 0);
+        ExitOnFailure(hr, "Failed to format REMOVE string.");
+
+        hr = StrAllocConcatSecure(psczArguments, scz, 0);
+        ExitOnFailure(hr, "Failed to concat argument string.");
+    }
+
+LExit:
+    ReleaseStr(scz);
+    ReleaseStr(sczAddLocal);
+    ReleaseStr(sczAddSource);
+    ReleaseStr(sczAddDefault);
+    ReleaseStr(sczReinstall);
+    ReleaseStr(sczAdvertise);
+    ReleaseStr(sczRemove);
+
+    return hr;
+}
+
+static HRESULT ConcatPatchProperty(
+    __in BURN_PACKAGE* pPackage,
+    __in_opt BOOTSTRAPPER_ACTION_STATE* rgSlipstreamPatchActions,
+    __inout_z LPWSTR* psczArguments
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR sczCachedDirectory = NULL;
+    LPWSTR sczMspPath = NULL;
+    LPWSTR sczPatches = NULL;
+
+    // If there are slipstream patch actions, build up their patch action.
+    if (rgSlipstreamPatchActions)
+    {
+        for (DWORD i = 0; i < pPackage->Msi.cSlipstreamMspPackages; ++i)
+        {
+            BURN_PACKAGE* pMspPackage = pPackage->Msi.rgpSlipstreamMspPackages[i];
+            AssertSz(BURN_PACKAGE_TYPE_MSP == pMspPackage->type, "Only MSP packages can be slipstream patches.");
+
+            BOOTSTRAPPER_ACTION_STATE patchExecuteAction = rgSlipstreamPatchActions[i];
+            if (BOOTSTRAPPER_ACTION_STATE_UNINSTALL < patchExecuteAction)
+            {
+                hr = CacheGetCompletedPath(pMspPackage->fPerMachine, pMspPackage->sczCacheId, &sczCachedDirectory);
+                ExitOnFailure(hr, "Failed to get cached path for MSP package: %ls", pMspPackage->sczId);
+
+                hr = PathConcat(sczCachedDirectory, pMspPackage->rgPayloads[0].pPayload->sczFilePath, &sczMspPath);
+                ExitOnFailure(hr, "Failed to build MSP path.");
+
+                if (!sczPatches)
+                {
+                    hr = StrAllocConcat(&sczPatches, L" PATCH=\"", 0);
+                    ExitOnFailure(hr, "Failed to prefix with PATCH property.");
+                }
+                else
+                {
+                    hr = StrAllocConcat(&sczPatches, L";", 0);
+                    ExitOnFailure(hr, "Failed to semi-colon delimit patches.");
+                }
+
+                hr = StrAllocConcat(&sczPatches, sczMspPath, 0);
+                ExitOnFailure(hr, "Failed to append patch path.");
+            }
+        }
+
+        if (sczPatches)
+        {
+            hr = StrAllocConcat(&sczPatches, L"\"", 0);
+            ExitOnFailure(hr, "Failed to close the quoted PATCH property.");
+
+            hr = StrAllocConcatSecure(psczArguments, sczPatches, 0);
+            ExitOnFailure(hr, "Failed to append PATCH property.");
+        }
+    }
+
+LExit:
+    ReleaseStr(sczMspPath);
+    ReleaseStr(sczCachedDirectory);
+    ReleaseStr(sczPatches);
+    return hr;
+}
+
+static void RegisterSourceDirectory(
+    __in BURN_PACKAGE* pPackage,
+    __in_z LPCWSTR wzMsiPath
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR sczMsiDirectory = NULL;
+    MSIINSTALLCONTEXT dwContext = pPackage->fPerMachine ? MSIINSTALLCONTEXT_MACHINE : MSIINSTALLCONTEXT_USERUNMANAGED;
+
+    hr = PathGetDirectory(wzMsiPath, &sczMsiDirectory);
+    ExitOnFailure(hr, "Failed to get directory for path: %ls", wzMsiPath);
+
+    hr = WiuSourceListAddSourceEx(pPackage->Msi.sczProductCode, NULL, dwContext, MSICODE_PRODUCT, sczMsiDirectory, 1);
+    if (FAILED(hr))
+    {
+        LogId(REPORT_VERBOSE, MSG_SOURCELIST_REGISTER, sczMsiDirectory, pPackage->Msi.sczProductCode, hr);
+        ExitFunction();
+    }
+
+LExit:
+    ReleaseStr(sczMsiDirectory);
+
+    return;
+}
diff --git a/src/engine/msiengine.h b/src/engine/msiengine.h
new file mode 100644
index 00000000..2a8ebfd5
--- /dev/null
+++ b/src/engine/msiengine.h
@@ -0,0 +1,73 @@
+#pragma once
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+
+// function declarations
+
+HRESULT MsiEngineParsePackageFromXml(
+    __in IXMLDOMNode* pixnBundle,
+    __in BURN_PACKAGE* pPackage
+    );
+HRESULT MsiEngineParsePropertiesFromXml(
+    __in IXMLDOMNode* pixnPackage,
+    __out BURN_MSIPROPERTY** prgProperties,
+    __out DWORD* pcProperties
+    );
+void MsiEnginePackageUninitialize(
+    __in BURN_PACKAGE* pPackage
+    );
+HRESULT MsiEngineDetectPackage(
+    __in BURN_PACKAGE* pPackage,
+    __in BURN_USER_EXPERIENCE* pUserExperience
+    );
+HRESULT MsiEnginePlanCalculatePackage(
+    __in BURN_PACKAGE* pPackage,
+    __in BURN_VARIABLES* pVariables,
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __out_opt BOOL* pfBARequestedCache
+    );
+HRESULT MsiEnginePlanAddPackage(
+    __in BOOTSTRAPPER_DISPLAY display,
+    __in BURN_PACKAGE* pPackage,
+    __in BURN_PLAN* pPlan,
+    __in BURN_LOGGING* pLog,
+    __in BURN_VARIABLES* pVariables,
+    __in_opt HANDLE hCacheEvent,
+    __in BOOL fPlanPackageCacheRollback
+    );
+HRESULT MsiEngineAddCompatiblePackage(
+    __in BURN_PACKAGES* pPackages,
+    __in const BURN_PACKAGE* pPackage,
+    __out_opt BURN_PACKAGE** ppCompatiblePackage
+    );
+HRESULT MsiEngineExecutePackage(
+    __in_opt HWND hwndParent,
+    __in BURN_EXECUTE_ACTION* pExecuteAction,
+    __in BURN_VARIABLES* pVariables,
+    __in BOOL fRollback,
+    __in PFN_MSIEXECUTEMESSAGEHANDLER pfnMessageHandler,
+    __in LPVOID pvContext,
+    __out BOOTSTRAPPER_APPLY_RESTART* pRestart
+    );
+HRESULT MsiEngineConcatProperties(
+    __in_ecount(cProperties) BURN_MSIPROPERTY* rgProperties,
+    __in DWORD cProperties,
+    __in BURN_VARIABLES* pVariables,
+    __in BOOL fRollback,
+    __deref_out_z LPWSTR* psczProperties,
+    __in BOOL fObfuscateHiddenVariables
+    );
+INSTALLUILEVEL MsiEngineCalculateInstallUiLevel(
+    __in BOOL fDisplayInternalUI,
+    __in BOOTSTRAPPER_DISPLAY display,
+    __in BOOTSTRAPPER_ACTION_STATE actionState
+    );
+
+#if defined(__cplusplus)
+}
+#endif
diff --git a/src/engine/mspengine.cpp b/src/engine/mspengine.cpp
new file mode 100644
index 00000000..463799e6
--- /dev/null
+++ b/src/engine/mspengine.cpp
@@ -0,0 +1,980 @@
+// 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.
+
+#include "precomp.h"
+
+
+// constants
+
+
+// structs
+
+struct POSSIBLE_TARGETPRODUCT
+{
+    WCHAR wzProductCode[39];
+    LPWSTR pszLocalPackage;
+    MSIINSTALLCONTEXT context;
+};
+
+// internal function declarations
+
+static HRESULT GetPossibleTargetProductCodes(
+    __in BURN_PACKAGES*     pPackages,
+    __deref_inout_ecount_opt(*pcPossibleTargetProductCodes) POSSIBLE_TARGETPRODUCT** prgPossibleTargetProductCodes,
+    __inout DWORD* pcPossibleTargetProductCodes
+    );
+static HRESULT AddPossibleTargetProduct(
+    __in STRINGDICT_HANDLE sdUniquePossibleTargetProductCodes,
+    __in_z LPCWSTR wzPossibleTargetProductCode,
+    __in MSIINSTALLCONTEXT context,
+    __deref_inout_ecount_opt(*pcPossibleTargetProducts) POSSIBLE_TARGETPRODUCT** prgPossibleTargetProducts,
+    __inout DWORD* pcPossibleTargetProducts
+    );
+static HRESULT AddDetectedTargetProduct(
+    __in BURN_PACKAGES* pPackages,
+    __in BURN_PACKAGE* pPackage,
+    __in DWORD dwOrder,
+    __in_z LPCWSTR wzProductCode,
+    __in MSIINSTALLCONTEXT context
+    );
+static void DeterminePatchChainedTarget(
+    __in BURN_PACKAGES* pPackages,
+    __in BURN_PACKAGE* pMspPackage,
+    __in LPCWSTR wzTargetProductCode,
+    __out BURN_PACKAGE** ppChainedTargetPackage,
+    __out BOOL* pfSlipstreamed
+    );
+static HRESULT PlanTargetProduct(
+    __in BOOTSTRAPPER_DISPLAY display,
+    __in BOOL fRollback,
+    __in BURN_PLAN* pPlan,
+    __in BURN_LOGGING* pLog,
+    __in BURN_VARIABLES* pVariables,
+    __in BOOTSTRAPPER_ACTION_STATE actionState,
+    __in BURN_PACKAGE* pPackage,
+    __in BURN_MSPTARGETPRODUCT* pTargetProduct,
+    __in_opt HANDLE hCacheEvent
+    );
+
+
+// function definitions
+
+extern "C" HRESULT MspEngineParsePackageFromXml(
+    __in IXMLDOMNode* pixnMspPackage,
+    __in BURN_PACKAGE* pPackage
+    )
+{
+    HRESULT hr = S_OK;
+
+    // @PatchCode
+    hr = XmlGetAttributeEx(pixnMspPackage, L"PatchCode", &pPackage->Msp.sczPatchCode);
+    ExitOnFailure(hr, "Failed to get @PatchCode.");
+
+    // @PatchXml
+    hr = XmlGetAttributeEx(pixnMspPackage, L"PatchXml", &pPackage->Msp.sczApplicabilityXml);
+    ExitOnFailure(hr, "Failed to get @PatchXml.");
+
+    // @DisplayInternalUI
+    hr = XmlGetYesNoAttribute(pixnMspPackage, L"DisplayInternalUI", &pPackage->Msp.fDisplayInternalUI);
+    ExitOnFailure(hr, "Failed to get @DisplayInternalUI.");
+
+    // Read properties.
+    hr = MsiEngineParsePropertiesFromXml(pixnMspPackage, &pPackage->Msp.rgProperties, &pPackage->Msp.cProperties);
+    ExitOnFailure(hr, "Failed to parse properties from XML.");
+
+LExit:
+
+    return hr;
+}
+
+extern "C" void MspEnginePackageUninitialize(
+    __in BURN_PACKAGE* pPackage
+    )
+{
+    ReleaseStr(pPackage->Msp.sczPatchCode);
+    ReleaseStr(pPackage->Msp.sczApplicabilityXml);
+
+    // free properties
+    if (pPackage->Msp.rgProperties)
+    {
+        for (DWORD i = 0; i < pPackage->Msp.cProperties; ++i)
+        {
+            BURN_MSIPROPERTY* pProperty = &pPackage->Msp.rgProperties[i];
+
+            ReleaseStr(pProperty->sczId);
+            ReleaseStr(pProperty->sczValue);
+            ReleaseStr(pProperty->sczRollbackValue);
+        }
+        MemFree(pPackage->Msp.rgProperties);
+    }
+
+    // free target products
+    ReleaseMem(pPackage->Msp.rgTargetProducts);
+
+    // clear struct
+    memset(&pPackage->Msp, 0, sizeof(pPackage->Msp));
+}
+
+extern "C" HRESULT MspEngineDetectInitialize(
+    __in BURN_PACKAGES* pPackages
+    )
+{
+    AssertSz(pPackages->cPatchInfo, "MspEngineDetectInitialize() should only be called if there are MSP packages.");
+
+    HRESULT hr = S_OK;
+    POSSIBLE_TARGETPRODUCT* rgPossibleTargetProducts = NULL;
+    DWORD cPossibleTargetProducts = 0;
+
+#ifdef DEBUG
+    // All patch info should be initialized to zero.
+    for (DWORD i = 0; i < pPackages->cPatchInfo; ++i)
+    {
+        BURN_PACKAGE* pPackage = pPackages->rgPatchInfoToPackage[i];
+        Assert(!pPackage->Msp.cTargetProductCodes);
+        Assert(!pPackage->Msp.rgTargetProducts);
+    }
+#endif
+
+    // Figure out which product codes to target on the machine. In the worst case all products on the machine
+    // will be returned.
+    hr = GetPossibleTargetProductCodes(pPackages, &rgPossibleTargetProducts, &cPossibleTargetProducts);
+    ExitOnFailure(hr, "Failed to get possible target product codes.");
+
+    // Loop through possible target products, testing the collective patch applicability against each product in
+    // the appropriate context. Store the result with the appropriate patch package.
+    for (DWORD iSearch = 0; iSearch < cPossibleTargetProducts; ++iSearch)
+    {
+        const POSSIBLE_TARGETPRODUCT* pPossibleTargetProduct = rgPossibleTargetProducts + iSearch;
+
+        LogId(REPORT_STANDARD, MSG_DETECT_CALCULATE_PATCH_APPLICABILITY, pPossibleTargetProduct->wzProductCode, LoggingMsiInstallContext(pPossibleTargetProduct->context));
+
+        if (pPossibleTargetProduct->pszLocalPackage)
+        {
+            // Ignores current machine state to determine just patch applicability.
+            // Superseded and obsolesced patches will be planned separately.
+            hr = WiuDetermineApplicablePatches(pPossibleTargetProduct->pszLocalPackage, pPackages->rgPatchInfo, pPackages->cPatchInfo);
+        }
+        else
+        {
+            hr = WiuDeterminePatchSequence(pPossibleTargetProduct->wzProductCode, NULL, pPossibleTargetProduct->context, pPackages->rgPatchInfo, pPackages->cPatchInfo);
+        }
+
+        if (SUCCEEDED(hr))
+        {
+            for (DWORD iPatchInfo = 0; iPatchInfo < pPackages->cPatchInfo; ++iPatchInfo)
+            {
+                if (ERROR_SUCCESS == pPackages->rgPatchInfo[iPatchInfo].uStatus)
+                {
+                    BURN_PACKAGE* pMspPackage = pPackages->rgPatchInfoToPackage[iPatchInfo];
+                    Assert(BURN_PACKAGE_TYPE_MSP == pMspPackage->type);
+
+                    // Note that we do add superseded and obsolete MSP packages. Package Detect and Plan will sort them out later.
+                    hr = AddDetectedTargetProduct(pPackages, pMspPackage, pPackages->rgPatchInfo[iPatchInfo].dwOrder, pPossibleTargetProduct->wzProductCode, pPossibleTargetProduct->context);
+                    ExitOnFailure(hr, "Failed to add target product code to package: %ls", pMspPackage->sczId);
+                }
+                // TODO: should we log something for this error case?
+            }
+        }
+        else
+        {
+            LogId(REPORT_STANDARD, MSG_DETECT_FAILED_CALCULATE_PATCH_APPLICABILITY, pPossibleTargetProduct->wzProductCode, LoggingMsiInstallContext(pPossibleTargetProduct->context), hr);
+        }
+
+        hr = S_OK; // always reset so we test all possible target products.
+    }
+
+LExit:
+    if (rgPossibleTargetProducts)
+    {
+        for (DWORD i = 0; i < cPossibleTargetProducts; ++i)
+        {
+            ReleaseStr(rgPossibleTargetProducts[i].pszLocalPackage);
+        }
+        MemFree(rgPossibleTargetProducts);
+    }
+
+    return hr;
+}
+
+extern "C" HRESULT MspEngineDetectPackage(
+    __in BURN_PACKAGE* pPackage,
+    __in BURN_USER_EXPERIENCE* pUserExperience
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR sczState = NULL;
+
+    if (0 == pPackage->Msp.cTargetProductCodes)
+    {
+        pPackage->currentState = BOOTSTRAPPER_PACKAGE_STATE_ABSENT;
+    }
+    else
+    {
+        // Start the package state at the the highest state then loop through all the
+        // target product codes and end up setting the current state to the lowest
+        // package state applied to the the target product codes.
+        pPackage->currentState = BOOTSTRAPPER_PACKAGE_STATE_SUPERSEDED;
+
+        for (DWORD i = 0; i < pPackage->Msp.cTargetProductCodes; ++i)
+        {
+            BURN_MSPTARGETPRODUCT* pTargetProduct = pPackage->Msp.rgTargetProducts + i;
+
+            hr = WiuGetPatchInfoEx(pPackage->Msp.sczPatchCode, pTargetProduct->wzTargetProductCode, NULL, pTargetProduct->context, INSTALLPROPERTY_PATCHSTATE, &sczState);
+            if (SUCCEEDED(hr))
+            {
+                switch (*sczState)
+                {
+                case '1':
+                    pTargetProduct->patchPackageState = BOOTSTRAPPER_PACKAGE_STATE_PRESENT;
+                    break;
+
+                case '2':
+                    pTargetProduct->patchPackageState = BOOTSTRAPPER_PACKAGE_STATE_SUPERSEDED;
+                    break;
+
+                case '4':
+                    pTargetProduct->patchPackageState = BOOTSTRAPPER_PACKAGE_STATE_OBSOLETE;
+                    break;
+
+                default:
+                    pTargetProduct->patchPackageState = BOOTSTRAPPER_PACKAGE_STATE_ABSENT;
+                    break;
+                }
+            }
+            else if (HRESULT_FROM_WIN32(ERROR_UNKNOWN_PATCH) == hr)
+            {
+                pTargetProduct->patchPackageState = BOOTSTRAPPER_PACKAGE_STATE_ABSENT;
+                hr = S_OK;
+            }
+            ExitOnFailure(hr, "Failed to get patch information for patch code: %ls, target product code: %ls", pPackage->Msp.sczPatchCode, pTargetProduct->wzTargetProductCode);
+
+            if (pPackage->currentState > pTargetProduct->patchPackageState)
+            {
+                pPackage->currentState = pTargetProduct->patchPackageState;
+            }
+
+            hr = UserExperienceOnDetectTargetMsiPackage(pUserExperience, pPackage->sczId, pTargetProduct->wzTargetProductCode, pTargetProduct->patchPackageState);
+            ExitOnRootFailure(hr, "BA aborted detect target MSI package.");
+        }
+    }
+
+LExit:
+    ReleaseStr(sczState);
+
+    return hr;
+}
+
+//
+// PlanCalculate - calculates the execute and rollback state for the requested package state.
+//
+extern "C" HRESULT MspEnginePlanCalculatePackage(
+    __in BURN_PACKAGE* pPackage,
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __out BOOL* pfBARequestedCache
+    )
+{
+    HRESULT hr = S_OK;
+    BOOL fBARequestedCache = FALSE;
+
+    for (DWORD i = 0; i < pPackage->Msp.cTargetProductCodes; ++i)
+    {
+        BURN_MSPTARGETPRODUCT* pTargetProduct = pPackage->Msp.rgTargetProducts + i;
+
+        BOOTSTRAPPER_REQUEST_STATE requested = pPackage->requested;
+        BOOTSTRAPPER_ACTION_STATE execute = BOOTSTRAPPER_ACTION_STATE_NONE;
+        BOOTSTRAPPER_ACTION_STATE rollback = BOOTSTRAPPER_ACTION_STATE_NONE;
+
+        hr = UserExperienceOnPlanTargetMsiPackage(pUserExperience, pPackage->sczId, pTargetProduct->wzTargetProductCode, &requested);
+        ExitOnRootFailure(hr, "BA aborted plan target MSI package.");
+
+        // Calculate the execute action.
+        switch (pTargetProduct->patchPackageState)
+        {
+        case BOOTSTRAPPER_PACKAGE_STATE_PRESENT:
+            switch (requested)
+            {
+            case BOOTSTRAPPER_REQUEST_STATE_REPAIR:
+                execute = BOOTSTRAPPER_ACTION_STATE_REPAIR;
+                break;
+
+            case BOOTSTRAPPER_REQUEST_STATE_ABSENT: __fallthrough;
+            case BOOTSTRAPPER_REQUEST_STATE_CACHE:
+                execute = pPackage->fUninstallable ? BOOTSTRAPPER_ACTION_STATE_UNINSTALL : BOOTSTRAPPER_ACTION_STATE_NONE;
+                break;
+
+            case BOOTSTRAPPER_REQUEST_STATE_FORCE_ABSENT:
+                execute = BOOTSTRAPPER_ACTION_STATE_UNINSTALL;
+                break;
+
+            default:
+                execute = BOOTSTRAPPER_ACTION_STATE_NONE;
+                break;
+            }
+            break;
+
+        case BOOTSTRAPPER_PACKAGE_STATE_ABSENT:
+            switch (requested)
+            {
+            case BOOTSTRAPPER_REQUEST_STATE_PRESENT: __fallthrough;
+            case BOOTSTRAPPER_REQUEST_STATE_REPAIR:
+                execute = BOOTSTRAPPER_ACTION_STATE_INSTALL;
+                break;
+
+            case BOOTSTRAPPER_REQUEST_STATE_CACHE:
+                execute = BOOTSTRAPPER_ACTION_STATE_NONE;
+                fBARequestedCache = TRUE;
+                break;
+
+            default:
+                execute = BOOTSTRAPPER_ACTION_STATE_NONE;
+                break;
+            }
+            break;
+        }
+
+        // Calculate the rollback action if there is an execute action.
+        if (BOOTSTRAPPER_ACTION_STATE_NONE != execute)
+        {
+            switch (BOOTSTRAPPER_PACKAGE_STATE_UNKNOWN != pPackage->expected ? pPackage->expected : pPackage->currentState)
+            {
+            case BOOTSTRAPPER_PACKAGE_STATE_PRESENT:
+                switch (requested)
+                {
+                case BOOTSTRAPPER_REQUEST_STATE_FORCE_ABSENT: __fallthrough;
+                case BOOTSTRAPPER_REQUEST_STATE_ABSENT:
+                    rollback = BOOTSTRAPPER_ACTION_STATE_INSTALL;
+                    break;
+
+                default:
+                    rollback = BOOTSTRAPPER_ACTION_STATE_NONE;
+                    break;
+                }
+                break;
+
+            case BOOTSTRAPPER_PACKAGE_STATE_ABSENT: __fallthrough;
+            case BOOTSTRAPPER_PACKAGE_STATE_CACHED:
+                switch (requested)
+                {
+                case BOOTSTRAPPER_REQUEST_STATE_PRESENT: __fallthrough;
+                case BOOTSTRAPPER_REQUEST_STATE_REPAIR:
+                    rollback = pPackage->fUninstallable ? BOOTSTRAPPER_ACTION_STATE_UNINSTALL : BOOTSTRAPPER_ACTION_STATE_NONE;
+                    break;
+
+                default:
+                    rollback = BOOTSTRAPPER_ACTION_STATE_NONE;
+                    break;
+                }
+                break;
+
+            default:
+                rollback = BOOTSTRAPPER_ACTION_STATE_NONE;
+                break;
+            }
+        }
+
+        pTargetProduct->execute = execute;
+        pTargetProduct->rollback = rollback;
+
+        // The highest aggregate action state found will be returned.
+        if (pPackage->execute < execute)
+        {
+            pPackage->execute = execute;
+        }
+
+        if (pPackage->rollback < rollback)
+        {
+            pPackage->rollback = rollback;
+        }
+    }
+
+    if (pfBARequestedCache)
+    {
+        *pfBARequestedCache = fBARequestedCache;
+    }
+
+LExit:
+
+    return hr;
+}
+
+//
+// PlanAdd - adds the calculated execute and rollback actions for the package.
+//
+extern "C" HRESULT MspEnginePlanAddPackage(
+    __in BOOTSTRAPPER_DISPLAY display,
+    __in BURN_PACKAGE* pPackage,
+    __in BURN_PLAN* pPlan,
+    __in BURN_LOGGING* pLog,
+    __in BURN_VARIABLES* pVariables,
+    __in_opt HANDLE hCacheEvent,
+    __in BOOL fPlanPackageCacheRollback
+    )
+{
+    HRESULT hr = S_OK;
+
+    // TODO: need to handle the case where this patch adds itself to an earlier patch's list of target products. That would
+    //       essentially bump this patch earlier in the plan and we need to make sure this patch is downloaded.
+    // add wait for cache
+    if (hCacheEvent)
+    {
+        hr = PlanExecuteCacheSyncAndRollback(pPlan, pPackage, hCacheEvent, fPlanPackageCacheRollback);
+        ExitOnFailure(hr, "Failed to plan package cache syncpoint");
+    }
+
+    hr = DependencyPlanPackage(NULL, pPackage, pPlan);
+    ExitOnFailure(hr, "Failed to plan package dependency actions.");
+
+    // Plan the actions for each target product code.
+    for (DWORD i = 0; i < pPackage->Msp.cTargetProductCodes; ++i)
+    {
+        BURN_MSPTARGETPRODUCT* pTargetProduct = pPackage->Msp.rgTargetProducts + i;
+
+        // If the dependency manager changed the action state for the patch, change the target product actions.
+        if (pPackage->fDependencyManagerWasHere)
+        {
+            pTargetProduct->execute = pPackage->execute;
+            pTargetProduct->rollback = pPackage->rollback;
+        }
+
+        if (BOOTSTRAPPER_ACTION_STATE_NONE != pTargetProduct->execute)
+        {
+            hr = PlanTargetProduct(display, FALSE, pPlan, pLog, pVariables, pTargetProduct->execute, pPackage, pTargetProduct, hCacheEvent);
+            ExitOnFailure(hr, "Failed to plan target product.");
+        }
+
+        if (BOOTSTRAPPER_ACTION_STATE_NONE != pTargetProduct->rollback)
+        {
+            hr = PlanTargetProduct(display, TRUE, pPlan, pLog, pVariables, pTargetProduct->rollback, pPackage, pTargetProduct, hCacheEvent);
+            ExitOnFailure(hr, "Failed to plan rollack target product.");
+        }
+    }
+
+LExit:
+
+    return hr;
+}
+
+extern "C" HRESULT MspEngineExecutePackage(
+    __in_opt HWND hwndParent,
+    __in BURN_EXECUTE_ACTION* pExecuteAction,
+    __in BURN_VARIABLES* pVariables,
+    __in BOOL fRollback,
+    __in PFN_MSIEXECUTEMESSAGEHANDLER pfnMessageHandler,
+    __in LPVOID pvContext,
+    __out BOOTSTRAPPER_APPLY_RESTART* pRestart
+    )
+{
+    HRESULT hr = S_OK;
+    INSTALLUILEVEL uiLevel = pExecuteAction->mspTarget.pPackage->Msp.fDisplayInternalUI ? INSTALLUILEVEL_DEFAULT : static_cast<INSTALLUILEVEL>(INSTALLUILEVEL_NONE | INSTALLUILEVEL_SOURCERESONLY);
+    WIU_MSI_EXECUTE_CONTEXT context = { };
+    WIU_RESTART restart = WIU_RESTART_NONE;
+
+    LPWSTR sczCachedDirectory = NULL;
+    LPWSTR sczMspPath = NULL;
+    LPWSTR sczPatches = NULL;
+    LPWSTR sczProperties = NULL;
+    LPWSTR sczObfuscatedProperties = NULL;
+
+    // default to "verbose" logging
+    DWORD dwLogMode = WIU_LOG_DEFAULT | INSTALLLOGMODE_VERBOSE;
+
+    // get cached MSP paths
+    for (DWORD i = 0; i < pExecuteAction->mspTarget.cOrderedPatches; ++i)
+    {
+        LPCWSTR wzAppend = NULL;
+        BURN_PACKAGE* pMspPackage = pExecuteAction->mspTarget.rgOrderedPatches[i].pPackage;
+        AssertSz(BURN_PACKAGE_TYPE_MSP == pMspPackage->type, "Invalid package type added to ordered patches.");
+
+        if (BOOTSTRAPPER_ACTION_STATE_INSTALL == pExecuteAction->mspTarget.action)
+        {
+            hr = CacheGetCompletedPath(pMspPackage->fPerMachine, pMspPackage->sczCacheId, &sczCachedDirectory);
+            ExitOnFailure(hr, "Failed to get cached path for MSP package: %ls", pMspPackage->sczId);
+
+            // TODO: Figure out if this makes sense -- the variable is set to the last patch's path only
+            // Best effort to set the execute package cache folder variable.
+            VariableSetString(pVariables, BURN_BUNDLE_EXECUTE_PACKAGE_CACHE_FOLDER, sczCachedDirectory, TRUE);
+
+            hr = PathConcat(sczCachedDirectory, pMspPackage->rgPayloads[0].pPayload->sczFilePath, &sczMspPath);
+            ExitOnFailure(hr, "Failed to build MSP path.");
+
+            wzAppend = sczMspPath;
+        }
+        else // uninstall
+        {
+            wzAppend = pMspPackage->Msp.sczPatchCode;
+        }
+
+        if (NULL != sczPatches)
+        {
+            hr = StrAllocConcat(&sczPatches, L";", 0);
+            ExitOnFailure(hr, "Failed to semi-colon delimit patches.");
+        }
+
+        hr = StrAllocConcat(&sczPatches, wzAppend, 0);
+        ExitOnFailure(hr, "Failed to append patch.");
+    }
+
+    // Best effort to set the execute package action variable.
+    VariableSetNumeric(pVariables, BURN_BUNDLE_EXECUTE_PACKAGE_ACTION, pExecuteAction->mspTarget.action, TRUE);
+
+    // Wire up the external UI handler and logging.
+    hr = WiuInitializeExternalUI(pfnMessageHandler, uiLevel, hwndParent, pvContext, fRollback, &context);
+    ExitOnFailure(hr, "Failed to initialize external UI handler.");
+
+    //if (BURN_LOGGING_LEVEL_DEBUG == logLevel)
+    //{
+    //    dwLogMode | INSTALLLOGMODE_EXTRADEBUG;
+    //}
+
+    if (pExecuteAction->mspTarget.sczLogPath && *pExecuteAction->mspTarget.sczLogPath)
+    {
+        hr = WiuEnableLog(dwLogMode, pExecuteAction->mspTarget.sczLogPath, 0);
+        ExitOnFailure(hr, "Failed to enable logging for package: %ls to: %ls", pExecuteAction->mspTarget.pPackage->sczId, pExecuteAction->mspTarget.sczLogPath);
+    }
+
+    // set up properties
+    hr = MsiEngineConcatProperties(pExecuteAction->mspTarget.pPackage->Msp.rgProperties, pExecuteAction->mspTarget.pPackage->Msp.cProperties, pVariables, fRollback, &sczProperties, FALSE);
+    ExitOnFailure(hr, "Failed to add properties to argument string.");
+
+    hr = MsiEngineConcatProperties(pExecuteAction->mspTarget.pPackage->Msp.rgProperties, pExecuteAction->mspTarget.pPackage->Msp.cProperties, pVariables, fRollback, &sczObfuscatedProperties, TRUE);
+    ExitOnFailure(hr, "Failed to add properties to obfuscated argument string.");
+
+    LogId(REPORT_STANDARD, MSG_APPLYING_PATCH_PACKAGE, pExecuteAction->mspTarget.pPackage->sczId, LoggingActionStateToString(pExecuteAction->mspTarget.action), sczPatches, sczObfuscatedProperties, pExecuteAction->mspTarget.sczTargetProductCode);
+
+    //
+    // Do the actual action.
+    //
+    switch (pExecuteAction->mspTarget.action)
+    {
+    case BOOTSTRAPPER_ACTION_STATE_INSTALL: __fallthrough;
+    case BOOTSTRAPPER_ACTION_STATE_REPAIR:
+        hr = StrAllocConcatSecure(&sczProperties, L" PATCH=\"", 0);
+        ExitOnFailure(hr, "Failed to add PATCH property on install.");
+
+        hr = StrAllocConcatSecure(&sczProperties, sczPatches, 0);
+        ExitOnFailure(hr, "Failed to add patches to PATCH property on install.");
+
+        hr = StrAllocConcatSecure(&sczProperties, L"\" REBOOT=ReallySuppress", 0);
+        ExitOnFailure(hr, "Failed to add reboot suppression property on install.");
+
+        hr = WiuConfigureProductEx(pExecuteAction->mspTarget.sczTargetProductCode, INSTALLLEVEL_DEFAULT, INSTALLSTATE_DEFAULT, sczProperties, &restart);
+        ExitOnFailure(hr, "Failed to install MSP package.");
+        break;
+
+    case BOOTSTRAPPER_ACTION_STATE_UNINSTALL:
+        hr = StrAllocConcatSecure(&sczProperties, L" REBOOT=ReallySuppress", 0);
+        ExitOnFailure(hr, "Failed to add reboot suppression property on uninstall.");
+
+        // Ignore all dependencies, since the Burn engine already performed the check.
+        hr = StrAllocFormattedSecure(&sczProperties, L"%ls %ls=ALL", sczProperties, DEPENDENCY_IGNOREDEPENDENCIES);
+        ExitOnFailure(hr, "Failed to add the list of dependencies to ignore to the properties.");
+
+        hr = WiuRemovePatches(sczPatches, pExecuteAction->mspTarget.sczTargetProductCode, sczProperties, &restart);
+        ExitOnFailure(hr, "Failed to uninstall MSP package.");
+        break;
+    }
+
+LExit:
+    WiuUninitializeExternalUI(&context);
+
+    ReleaseStr(sczCachedDirectory);
+    ReleaseStr(sczMspPath);
+    StrSecureZeroFreeString(sczProperties);
+    ReleaseStr(sczObfuscatedProperties);
+    ReleaseStr(sczPatches);
+
+    switch (restart)
+    {
+        case WIU_RESTART_NONE:
+            *pRestart = BOOTSTRAPPER_APPLY_RESTART_NONE;
+            break;
+
+        case WIU_RESTART_REQUIRED:
+            *pRestart = BOOTSTRAPPER_APPLY_RESTART_REQUIRED;
+            break;
+
+        case WIU_RESTART_INITIATED:
+            *pRestart = BOOTSTRAPPER_APPLY_RESTART_INITIATED;
+            break;
+    }
+
+    // Best effort to clear the execute package cache folder and action variables.
+    VariableSetString(pVariables, BURN_BUNDLE_EXECUTE_PACKAGE_CACHE_FOLDER, NULL, TRUE);
+    VariableSetString(pVariables, BURN_BUNDLE_EXECUTE_PACKAGE_ACTION, NULL, TRUE);
+
+    return hr;
+}
+
+extern "C" void MspEngineSlipstreamUpdateState(
+    __in BURN_PACKAGE* pPackage,
+    __in BOOTSTRAPPER_ACTION_STATE execute,
+    __in BOOTSTRAPPER_ACTION_STATE rollback
+    )
+{
+    Assert(BURN_PACKAGE_TYPE_MSP == pPackage->type);
+
+    // If the dependency manager set our state then that means something else
+    // is dependent on our package. That trumps whatever the slipstream update
+    // state might set.
+    if (!pPackage->fDependencyManagerWasHere)
+    {
+        // The highest aggregate action state found will be returned.
+        if (pPackage->execute < execute)
+        {
+            pPackage->execute = execute;
+        }
+
+        if (pPackage->rollback < rollback)
+        {
+            pPackage->rollback = rollback;
+        }
+    }
+}
+
+
+// internal helper functions
+
+static HRESULT GetPossibleTargetProductCodes(
+    __in BURN_PACKAGES* pPackages,
+    __deref_inout_ecount_opt(*pcPossibleTargetProducts) POSSIBLE_TARGETPRODUCT** prgPossibleTargetProducts,
+    __inout DWORD* pcPossibleTargetProducts
+    )
+{
+    HRESULT hr = S_OK;
+    STRINGDICT_HANDLE sdUniquePossibleTargetProductCodes = NULL;
+    BOOL fCheckAll = FALSE;
+    WCHAR wzPossibleTargetProductCode[MAX_GUID_CHARS + 1];
+
+    // Use a dictionary to ensure we capture unique product codes. Otherwise, we could end up
+    // doing patch applicability for the same product code multiple times and that would confuse
+    // everything down stream.
+    hr = DictCreateStringList(&sdUniquePossibleTargetProductCodes, 5, DICT_FLAG_NONE);
+    ExitOnFailure(hr, "Failed to create unique target product codes.");
+
+    // If the patches target a specific set of product/upgrade codes, search only those. This
+    // should be much faster than searching all packages on the machine.
+    if (pPackages->rgPatchTargetCodes)
+    {
+        for (DWORD i = 0; i < pPackages->cPatchTargetCodes; ++i)
+        {
+            BURN_PATCH_TARGETCODE* pTargetCode = pPackages->rgPatchTargetCodes + i;
+
+            // If targeting a product, add the unique product code to the list.
+            if (BURN_PATCH_TARGETCODE_TYPE_PRODUCT == pTargetCode->type)
+            {
+                hr = AddPossibleTargetProduct(sdUniquePossibleTargetProductCodes, pTargetCode->sczTargetCode, MSIINSTALLCONTEXT_NONE, prgPossibleTargetProducts, pcPossibleTargetProducts);
+                ExitOnFailure(hr, "Failed to add product code to possible target product codes.");
+            }
+            else if (BURN_PATCH_TARGETCODE_TYPE_UPGRADE == pTargetCode->type)
+            {
+                // Enumerate all unique related products to the target upgrade code.
+                for (DWORD iProduct = 0; SUCCEEDED(hr); ++iProduct)
+                {
+                    hr = WiuEnumRelatedProducts(pTargetCode->sczTargetCode, iProduct, wzPossibleTargetProductCode);
+                    if (SUCCEEDED(hr))
+                    {
+                        hr = AddPossibleTargetProduct(sdUniquePossibleTargetProductCodes, wzPossibleTargetProductCode, MSIINSTALLCONTEXT_NONE, prgPossibleTargetProducts, pcPossibleTargetProducts);
+                        ExitOnFailure(hr, "Failed to add upgrade product code to possible target product codes.");
+                    }
+                    else if (E_BADCONFIGURATION == hr)
+                    {
+                        // Skip product's with bad configuration and continue.
+                        LogId(REPORT_STANDARD, MSG_DETECT_BAD_PRODUCT_CONFIGURATION, wzPossibleTargetProductCode);
+
+                        hr = S_OK;
+                    }
+                }
+
+                if (E_NOMOREITEMS == hr)
+                {
+                    hr = S_OK;
+                }
+                ExitOnFailure(hr, "Failed to enumerate all products to patch related to upgrade code: %ls", pTargetCode->sczTargetCode);
+            }
+            else
+            {
+                // The element does not target a specific product.
+                fCheckAll = TRUE;
+
+                break;
+            }
+        }
+    }
+    else
+    {
+        fCheckAll = TRUE;
+    }
+
+    // One or more of the patches do not target a specific product so search everything on the machine.
+    if (fCheckAll)
+    {
+        for (DWORD iProduct = 0; SUCCEEDED(hr); ++iProduct)
+        {
+            MSIINSTALLCONTEXT context = MSIINSTALLCONTEXT_NONE;
+
+            hr = WiuEnumProductsEx(NULL, NULL, MSIINSTALLCONTEXT_ALL, iProduct, wzPossibleTargetProductCode, &context, NULL, NULL);
+            if (SUCCEEDED(hr))
+            {
+                hr = AddPossibleTargetProduct(sdUniquePossibleTargetProductCodes, wzPossibleTargetProductCode, context, prgPossibleTargetProducts, pcPossibleTargetProducts);
+                ExitOnFailure(hr, "Failed to add product code to search product codes.");
+            }
+            else if (E_BADCONFIGURATION == hr)
+            {
+                // Skip products with bad configuration and continue.
+                LogId(REPORT_STANDARD, MSG_DETECT_BAD_PRODUCT_CONFIGURATION, wzPossibleTargetProductCode);
+
+                hr = S_OK;
+            }
+        }
+
+        if (E_NOMOREITEMS == hr)
+        {
+            hr = S_OK;
+        }
+        ExitOnFailure(hr, "Failed to enumerate all products on the machine for patches applicability.");
+    }
+
+LExit:
+    ReleaseDict(sdUniquePossibleTargetProductCodes);
+
+    return hr;
+}
+
+static HRESULT AddPossibleTargetProduct(
+    __in STRINGDICT_HANDLE sdUniquePossibleTargetProductCodes,
+    __in_z LPCWSTR wzPossibleTargetProductCode,
+    __in MSIINSTALLCONTEXT context,
+    __deref_inout_ecount_opt(*pcPossibleTargetProducts) POSSIBLE_TARGETPRODUCT** prgPossibleTargetProducts,
+    __inout DWORD* pcPossibleTargetProducts
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR pszLocalPackage = NULL;
+
+    // Only add this possible target code if we haven't queried for it already.
+    if (E_NOTFOUND == DictKeyExists(sdUniquePossibleTargetProductCodes, wzPossibleTargetProductCode))
+    {
+        // If the install context is not known, ask the Windows Installer for it. If we can't get the context
+        // then bail.
+        if (MSIINSTALLCONTEXT_NONE == context)
+        {
+            hr = WiuEnumProductsEx(wzPossibleTargetProductCode, NULL, MSIINSTALLCONTEXT_ALL, 0, NULL, &context, NULL, NULL);
+            if (FAILED(hr))
+            {
+                ExitFunction1(hr = S_OK);
+            }
+        }
+
+        hr = DictAddKey(sdUniquePossibleTargetProductCodes, wzPossibleTargetProductCode);
+        ExitOnFailure(hr, "Failed to add possible target code to unique product codes.");
+
+        hr = MemEnsureArraySize(reinterpret_cast<LPVOID*>(prgPossibleTargetProducts), *pcPossibleTargetProducts + 1, sizeof(POSSIBLE_TARGETPRODUCT), 3);
+        ExitOnFailure(hr, "Failed to grow array of possible target products.");
+
+        POSSIBLE_TARGETPRODUCT *const pPossibleTargetProduct = *prgPossibleTargetProducts + *pcPossibleTargetProducts;
+
+        hr = ::StringCchCopyW(pPossibleTargetProduct->wzProductCode, countof(pPossibleTargetProduct->wzProductCode), wzPossibleTargetProductCode);
+        ExitOnFailure(hr, "Failed to copy possible target product code.");
+
+        // Attempt to get the local package path so we can more quickly determine patch applicability later.
+        hr = WiuGetProductInfoEx(wzPossibleTargetProductCode, NULL, context, INSTALLPROPERTY_LOCALPACKAGE, &pszLocalPackage);
+        if (SUCCEEDED(hr))
+        {
+            pPossibleTargetProduct->pszLocalPackage = pszLocalPackage;
+            pszLocalPackage = NULL;
+        }
+        else
+        {
+            // Will instead call MsiDeterminePatchSequence later.
+            hr = S_OK;
+        }
+
+        pPossibleTargetProduct->context = context;
+
+        ++(*pcPossibleTargetProducts);
+    }
+
+LExit:
+    ReleaseStr(pszLocalPackage);
+
+    return hr;
+}
+
+static HRESULT AddDetectedTargetProduct(
+    __in BURN_PACKAGES* pPackages,
+    __in BURN_PACKAGE* pPackage,
+    __in DWORD dwOrder,
+    __in_z LPCWSTR wzProductCode,
+    __in MSIINSTALLCONTEXT context
+    )
+{
+    HRESULT hr = S_OK;
+
+    hr = MemEnsureArraySize(reinterpret_cast<LPVOID*>(&pPackage->Msp.rgTargetProducts), pPackage->Msp.cTargetProductCodes + 1, sizeof(BURN_MSPTARGETPRODUCT), 5);
+    ExitOnFailure(hr, "Failed to ensure enough target product codes were allocated.");
+
+    hr = ::StringCchCopyW(pPackage->Msp.rgTargetProducts[pPackage->Msp.cTargetProductCodes].wzTargetProductCode, countof(pPackage->Msp.rgTargetProducts[pPackage->Msp.cTargetProductCodes].wzTargetProductCode), wzProductCode);
+    ExitOnFailure(hr, "Failed to copy target product code.");
+
+    DeterminePatchChainedTarget(pPackages, pPackage, wzProductCode,
+                                &pPackage->Msp.rgTargetProducts[pPackage->Msp.cTargetProductCodes].pChainedTargetPackage,
+                                &pPackage->Msp.rgTargetProducts[pPackage->Msp.cTargetProductCodes].fSlipstream);
+
+    pPackage->Msp.rgTargetProducts[pPackage->Msp.cTargetProductCodes].context = context;
+    pPackage->Msp.rgTargetProducts[pPackage->Msp.cTargetProductCodes].dwOrder = dwOrder;
+    ++pPackage->Msp.cTargetProductCodes;
+
+LExit:
+    return hr;
+}
+
+static void DeterminePatchChainedTarget(
+    __in BURN_PACKAGES* pPackages,
+    __in BURN_PACKAGE* pMspPackage,
+    __in LPCWSTR wzTargetProductCode,
+    __out BURN_PACKAGE** ppChainedTargetPackage,
+    __out BOOL* pfSlipstreamed
+    )
+{
+    BURN_PACKAGE* pTargetMsiPackage = NULL;
+    BOOL fSlipstreamed = FALSE;
+
+    for (DWORD iPackage = 0; iPackage < pPackages->cPackages; ++iPackage)
+    {
+        BURN_PACKAGE* pPackage = pPackages->rgPackages + iPackage;
+
+        if (BURN_PACKAGE_TYPE_MSI == pPackage->type && CSTR_EQUAL == ::CompareStringW(LOCALE_NEUTRAL, 0, wzTargetProductCode, -1, pPackage->Msi.sczProductCode, -1))
+        {
+            pTargetMsiPackage = pPackage;
+
+            for (DWORD j = 0; j < pPackage->Msi.cSlipstreamMspPackages; ++j)
+            {
+                BURN_PACKAGE* pSlipstreamMsp = pPackage->Msi.rgpSlipstreamMspPackages[j];
+                if (pSlipstreamMsp == pMspPackage)
+                {
+                    AssertSz(!fSlipstreamed, "An MSP should only show up as a slipstreamed patch in an MSI once.");
+                    fSlipstreamed = TRUE;
+                    break;
+                }
+            }
+
+            break;
+        }
+    }
+
+    *ppChainedTargetPackage = pTargetMsiPackage;
+    *pfSlipstreamed = fSlipstreamed;
+
+    return;
+}
+
+static HRESULT PlanTargetProduct(
+    __in BOOTSTRAPPER_DISPLAY display,
+    __in BOOL fRollback,
+    __in BURN_PLAN* pPlan,
+    __in BURN_LOGGING* pLog,
+    __in BURN_VARIABLES* pVariables,
+    __in BOOTSTRAPPER_ACTION_STATE actionState,
+    __in BURN_PACKAGE* pPackage,
+    __in BURN_MSPTARGETPRODUCT* pTargetProduct,
+    __in_opt HANDLE hCacheEvent
+    )
+{
+    HRESULT hr = S_OK;
+    BURN_EXECUTE_ACTION* rgActions = fRollback ? pPlan->rgRollbackActions : pPlan->rgExecuteActions;
+    DWORD cActions = fRollback ? pPlan->cRollbackActions : pPlan->cExecuteActions;
+    BURN_EXECUTE_ACTION* pAction = NULL;
+    DWORD dwInsertSequence = 0;
+
+    // Try to find another MSP action with the exact same action (install or uninstall) targeting
+    // the same product in the same machine context (per-user or per-machine).
+    for (DWORD i = 0; i < cActions; ++i)
+    {
+        pAction = rgActions + i;
+
+        if (BURN_EXECUTE_ACTION_TYPE_MSP_TARGET == pAction->type &&
+            pAction->mspTarget.action == actionState &&
+            pAction->mspTarget.fPerMachineTarget == (MSIINSTALLCONTEXT_MACHINE == pTargetProduct->context) &&
+            CSTR_EQUAL == ::CompareStringW(LOCALE_NEUTRAL, 0, pAction->mspTarget.sczTargetProductCode, -1, pTargetProduct->wzTargetProductCode, -1))
+        {
+            dwInsertSequence = i;
+            break;
+        }
+
+        pAction = NULL;
+    }
+
+    // If we didn't find an MSP target action already updating the product, create a new action.
+    if (!pAction)
+    {
+        if (fRollback)
+        {
+            hr = PlanAppendRollbackAction(pPlan, &pAction);
+        }
+        else
+        {
+            hr = PlanAppendExecuteAction(pPlan, &pAction);
+        }
+        ExitOnFailure(hr, "Failed to plan action for target product.");
+
+        pAction->type = BURN_EXECUTE_ACTION_TYPE_MSP_TARGET;
+        pAction->mspTarget.action = actionState;
+        pAction->mspTarget.pPackage = pPackage;
+        pAction->mspTarget.fPerMachineTarget = (MSIINSTALLCONTEXT_MACHINE == pTargetProduct->context);
+        pAction->mspTarget.uiLevel = MsiEngineCalculateInstallUiLevel(pPackage->Msp.fDisplayInternalUI, display, pAction->mspTarget.action);
+        pAction->mspTarget.pChainedTargetPackage = pTargetProduct->pChainedTargetPackage;
+        pAction->mspTarget.fSlipstream = pTargetProduct->fSlipstream;
+        hr = StrAllocString(&pAction->mspTarget.sczTargetProductCode, pTargetProduct->wzTargetProductCode, 0);
+        ExitOnFailure(hr, "Failed to copy target product code.");
+
+        // If this is a per-machine target product, then the plan needs to be per-machine as well.
+        if (pAction->mspTarget.fPerMachineTarget)
+        {
+            pPlan->fPerMachine = TRUE;
+        }
+
+        LoggingSetPackageVariable(pPackage, pAction->mspTarget.sczTargetProductCode, fRollback, pLog, pVariables, &pAction->mspTarget.sczLogPath); // ignore errors.
+    }
+    else
+    {
+        if (!fRollback && hCacheEvent)
+        {
+            // Since a previouse MSP target action is being updated with the new MSP, 
+            // insert a wait syncpoint to before this action since we need to cache the current MSI before using it.
+            BURN_EXECUTE_ACTION* pWaitSyncPointAction = NULL;
+            hr = PlanInsertExecuteAction(dwInsertSequence, pPlan, &pWaitSyncPointAction);
+            ExitOnFailure(hr, "Failed to insert execute action.");
+
+            pWaitSyncPointAction->type = BURN_EXECUTE_ACTION_TYPE_WAIT_SYNCPOINT;
+            pWaitSyncPointAction->syncpoint.hEvent = hCacheEvent;
+
+            // Since we inserted an action before the MSP target action that we will be updating, need to update the pointer.
+            pAction = pPlan->rgExecuteActions + (dwInsertSequence + 1);
+        }
+    }
+
+    // Add our target product to the array and sort based on their order determined during detection.
+    hr = MemEnsureArraySize(reinterpret_cast<LPVOID*>(&pAction->mspTarget.rgOrderedPatches), pAction->mspTarget.cOrderedPatches + 1, sizeof(BURN_ORDERED_PATCHES), 2);
+    ExitOnFailure(hr, "Failed grow array of ordered patches.");
+
+    pAction->mspTarget.rgOrderedPatches[pAction->mspTarget.cOrderedPatches].dwOrder = pTargetProduct->dwOrder;
+    pAction->mspTarget.rgOrderedPatches[pAction->mspTarget.cOrderedPatches].pPackage = pPackage;
+    ++pAction->mspTarget.cOrderedPatches;
+
+    // Insertion sort to keep the patches ordered.
+    for (DWORD i = pAction->mspTarget.cOrderedPatches - 1; i > 0; --i)
+    {
+        if (pAction->mspTarget.rgOrderedPatches[i].dwOrder < pAction->mspTarget.rgOrderedPatches[i - 1].dwOrder)
+        {
+            BURN_ORDERED_PATCHES temp = pAction->mspTarget.rgOrderedPatches[i - 1];
+            pAction->mspTarget.rgOrderedPatches[i - 1] = pAction->mspTarget.rgOrderedPatches[i];
+            pAction->mspTarget.rgOrderedPatches[i] = temp;
+        }
+        else // no swap necessary, we're done.
+        {
+            break;
+        }
+    }
+
+LExit:
+    return hr;
+}
diff --git a/src/engine/mspengine.h b/src/engine/mspengine.h
new file mode 100644
index 00000000..9f585720
--- /dev/null
+++ b/src/engine/mspengine.h
@@ -0,0 +1,67 @@
+#pragma once
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+
+// constants
+
+
+// structures
+
+
+// typedefs
+
+
+// function declarations
+
+HRESULT MspEngineParsePackageFromXml(
+    __in IXMLDOMNode* pixnBundle,
+    __in BURN_PACKAGE* pPackage
+    );
+void MspEnginePackageUninitialize(
+    __in BURN_PACKAGE* pPackage
+    );
+HRESULT MspEngineDetectInitialize(
+    __in BURN_PACKAGES* pPackages
+    );
+HRESULT MspEngineDetectPackage(
+    __in BURN_PACKAGE* pPackage,
+    __in BURN_USER_EXPERIENCE* pUserExperience
+    );
+HRESULT MspEnginePlanCalculatePackage(
+    __in BURN_PACKAGE* pPackage,
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __out_opt BOOL* pfBARequestedCache
+    );
+HRESULT MspEnginePlanAddPackage(
+    __in BOOTSTRAPPER_DISPLAY display,
+    __in BURN_PACKAGE* pPackage,
+    __in BURN_PLAN* pPlan,
+    __in BURN_LOGGING* pLog,
+    __in BURN_VARIABLES* pVariables,
+    __in_opt HANDLE hCacheEvent,
+    __in BOOL fPlanPackageCacheRollback
+    );
+HRESULT MspEngineExecutePackage(
+    __in_opt HWND hwndParent,
+    __in BURN_EXECUTE_ACTION* pExecuteAction,
+    __in BURN_VARIABLES* pVariables,
+    __in BOOL fRollback,
+    __in PFN_MSIEXECUTEMESSAGEHANDLER pfnMessageHandler,
+    __in LPVOID pvContext,
+    __out BOOTSTRAPPER_APPLY_RESTART* pRestart
+    );
+void MspEngineSlipstreamUpdateState(
+    __in BURN_PACKAGE* pMspPackage,
+    __in BOOTSTRAPPER_ACTION_STATE execute,
+    __in BOOTSTRAPPER_ACTION_STATE rollback
+    );
+
+
+#if defined(__cplusplus)
+}
+#endif
diff --git a/src/engine/msuengine.cpp b/src/engine/msuengine.cpp
new file mode 100644
index 00000000..3818e932
--- /dev/null
+++ b/src/engine/msuengine.cpp
@@ -0,0 +1,513 @@
+// 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.
+
+#include "precomp.h"
+
+
+// constants
+
+#define WU_S_REBOOT_REQUIRED        0x00240005L
+#define WU_S_ALREADY_INSTALLED      0x00240006L
+
+
+// function definitions
+static HRESULT EnsureWUServiceEnabled(
+    __in BOOL fStopWusaService,
+    __out SC_HANDLE* pschWu,
+    __out BOOL* pfPreviouslyDisabled
+    );
+static HRESULT SetServiceStartType(
+    __in SC_HANDLE sch,
+    __in DWORD stratType
+    );
+static HRESULT StopWUService(
+    __in SC_HANDLE schWu
+    );
+
+
+extern "C" HRESULT MsuEngineParsePackageFromXml(
+    __in IXMLDOMNode* pixnMsuPackage,
+    __in BURN_PACKAGE* pPackage
+    )
+{
+    HRESULT hr = S_OK;
+
+    // @KB
+    hr = XmlGetAttributeEx(pixnMsuPackage, L"KB", &pPackage->Msu.sczKB);
+    ExitOnFailure(hr, "Failed to get @KB.");
+
+    // @DetectCondition
+    hr = XmlGetAttributeEx(pixnMsuPackage, L"DetectCondition", &pPackage->Msu.sczDetectCondition);
+    ExitOnFailure(hr, "Failed to get @DetectCondition.");
+
+LExit:
+    return hr;
+}
+
+extern "C" void MsuEnginePackageUninitialize(
+    __in BURN_PACKAGE* pPackage
+    )
+{
+    ReleaseNullStr(pPackage->Msu.sczKB);
+    ReleaseNullStr(pPackage->Msu.sczDetectCondition);
+}
+
+extern "C" HRESULT MsuEngineDetectPackage(
+    __in BURN_PACKAGE* pPackage,
+    __in BURN_VARIABLES* pVariables
+    )
+{
+    HRESULT hr = S_OK;
+    BOOL fDetected = FALSE;
+
+    // evaluate detect condition
+    if (pPackage->Msu.sczDetectCondition && *pPackage->Msu.sczDetectCondition)
+    {
+        hr = ConditionEvaluate(pVariables, pPackage->Msu.sczDetectCondition, &fDetected);
+        ExitOnFailure(hr, "Failed to evaluate MSU package detect condition.");
+    }
+
+    // update detect state
+    pPackage->currentState = fDetected ? BOOTSTRAPPER_PACKAGE_STATE_PRESENT : BOOTSTRAPPER_PACKAGE_STATE_ABSENT;
+
+LExit:
+    return hr;
+}
+
+//
+// PlanCalculate - calculates the execute and rollback state for the requested package state.
+//
+extern "C" HRESULT MsuEnginePlanCalculatePackage(
+    __in BURN_PACKAGE* pPackage,
+    __out_opt BOOL* pfBARequestedCache
+    )
+{
+    HRESULT hr = S_OK;
+    BOOTSTRAPPER_ACTION_STATE execute = BOOTSTRAPPER_ACTION_STATE_NONE;
+    BOOTSTRAPPER_ACTION_STATE rollback = BOOTSTRAPPER_ACTION_STATE_NONE;
+    BOOL fBARequestedCache = FALSE;
+
+    BOOL fAllowUninstall = FALSE;
+    OS_VERSION osVersion = OS_VERSION_UNKNOWN;
+    DWORD dwServicePack = 0;
+
+    // We can only uninstall MSU packages if they have a KB and we are on Win7 or newer.
+    OsGetVersion(&osVersion, &dwServicePack);
+    fAllowUninstall = (pPackage->Msu.sczKB && *pPackage->Msu.sczKB) && OS_VERSION_WIN7 <= osVersion;
+
+    // execute action
+    switch (pPackage->currentState)
+    {
+    case BOOTSTRAPPER_PACKAGE_STATE_PRESENT:
+        switch (pPackage->requested)
+        {
+        case BOOTSTRAPPER_REQUEST_STATE_PRESENT: __fallthrough;
+        case BOOTSTRAPPER_REQUEST_STATE_REPAIR:
+            execute = BOOTSTRAPPER_ACTION_STATE_NONE;
+            break;
+
+        case BOOTSTRAPPER_REQUEST_STATE_ABSENT: __fallthrough;
+        case BOOTSTRAPPER_REQUEST_STATE_CACHE:
+            execute = fAllowUninstall && pPackage->fUninstallable ? BOOTSTRAPPER_ACTION_STATE_UNINSTALL : BOOTSTRAPPER_ACTION_STATE_NONE;
+            break;
+
+        case BOOTSTRAPPER_REQUEST_STATE_FORCE_ABSENT:
+            execute = fAllowUninstall ? BOOTSTRAPPER_ACTION_STATE_UNINSTALL : BOOTSTRAPPER_ACTION_STATE_NONE;
+            break;
+
+        default:
+            execute = BOOTSTRAPPER_ACTION_STATE_NONE;
+            break;
+        }
+        break;
+
+    case BOOTSTRAPPER_PACKAGE_STATE_ABSENT:
+        switch (pPackage->requested)
+        {
+        case BOOTSTRAPPER_REQUEST_STATE_PRESENT: __fallthrough;
+        case BOOTSTRAPPER_REQUEST_STATE_REPAIR:
+            execute = BOOTSTRAPPER_ACTION_STATE_INSTALL;
+            break;
+
+        case BOOTSTRAPPER_REQUEST_STATE_CACHE:
+            execute = BOOTSTRAPPER_ACTION_STATE_NONE;
+            fBARequestedCache = TRUE;
+
+        default:
+            execute = BOOTSTRAPPER_ACTION_STATE_NONE;
+            break;
+        }
+        break;
+
+    default:
+        hr = E_INVALIDARG;
+        ExitOnRootFailure(hr, "Invalid package state.");
+    }
+
+    // Calculate the rollback action if there is an execute action.
+    if (BOOTSTRAPPER_ACTION_STATE_NONE != execute)
+    {
+        switch (BOOTSTRAPPER_PACKAGE_STATE_UNKNOWN != pPackage->expected ? pPackage->expected : pPackage->currentState)
+        {
+        case BOOTSTRAPPER_PACKAGE_STATE_PRESENT:
+            switch (pPackage->requested)
+            {
+            case BOOTSTRAPPER_REQUEST_STATE_FORCE_ABSENT: __fallthrough;
+            case BOOTSTRAPPER_REQUEST_STATE_ABSENT:
+                rollback = BOOTSTRAPPER_ACTION_STATE_INSTALL;
+                break;
+
+            default:
+                rollback = BOOTSTRAPPER_ACTION_STATE_NONE;
+                break;
+            }
+            break;
+
+        case BOOTSTRAPPER_PACKAGE_STATE_ABSENT:
+            switch (pPackage->requested)
+            {
+            case BOOTSTRAPPER_REQUEST_STATE_PRESENT: __fallthrough;
+            case BOOTSTRAPPER_REQUEST_STATE_REPAIR:
+                rollback = fAllowUninstall ? BOOTSTRAPPER_ACTION_STATE_UNINSTALL : BOOTSTRAPPER_ACTION_STATE_NONE;
+                break;
+
+            default:
+                rollback = BOOTSTRAPPER_ACTION_STATE_NONE;
+                break;
+            }
+            break;
+
+        default:
+            hr = E_INVALIDARG;
+            ExitOnRootFailure(hr, "Invalid package expected state.");
+        }
+    }
+
+    // return values
+    pPackage->execute = execute;
+    pPackage->rollback = rollback;
+
+    if (pfBARequestedCache)
+    {
+        *pfBARequestedCache = fBARequestedCache;
+    }
+
+LExit:
+    return hr;
+}
+
+//
+// PlanAdd - adds the calculated execute and rollback actions for the package.
+//
+extern "C" HRESULT MsuEnginePlanAddPackage(
+    __in BURN_PACKAGE* pPackage,
+    __in BURN_PLAN* pPlan,
+    __in BURN_LOGGING* pLog,
+    __in BURN_VARIABLES* pVariables,
+    __in HANDLE hCacheEvent,
+    __in BOOL fPlanPackageCacheRollback
+    )
+{
+    HRESULT hr = S_OK;
+    BURN_EXECUTE_ACTION* pAction = NULL;
+
+    // add wait for cache
+    if (hCacheEvent)
+    {
+        hr = PlanExecuteCacheSyncAndRollback(pPlan, pPackage, hCacheEvent, fPlanPackageCacheRollback);
+        ExitOnFailure(hr, "Failed to plan package cache syncpoint");
+    }
+
+    hr = DependencyPlanPackage(NULL, pPackage, pPlan);
+    ExitOnFailure(hr, "Failed to plan package dependency actions.");
+
+    // add execute action
+    if (BOOTSTRAPPER_ACTION_STATE_NONE != pPackage->execute)
+    {
+        hr = PlanAppendExecuteAction(pPlan, &pAction);
+        ExitOnFailure(hr, "Failed to append execute action.");
+
+        pAction->type = BURN_EXECUTE_ACTION_TYPE_MSU_PACKAGE;
+        pAction->msuPackage.pPackage = pPackage;
+        pAction->msuPackage.action = pPackage->execute;
+
+        LoggingSetPackageVariable(pPackage, NULL, FALSE, pLog, pVariables, &pAction->msuPackage.sczLogPath); // ignore errors.
+    }
+
+    // add rollback action
+    if (BOOTSTRAPPER_ACTION_STATE_NONE != pPackage->rollback)
+    {
+        hr = PlanAppendRollbackAction(pPlan, &pAction);
+        ExitOnFailure(hr, "Failed to append rollback action.");
+
+        pAction->type = BURN_EXECUTE_ACTION_TYPE_MSU_PACKAGE;
+        pAction->msuPackage.pPackage = pPackage;
+        pAction->msuPackage.action = pPackage->rollback;
+
+        LoggingSetPackageVariable(pPackage, NULL, TRUE, pLog, pVariables, &pAction->msuPackage.sczLogPath); // ignore errors.
+    }
+
+LExit:
+    return hr;
+}
+
+extern "C" HRESULT MsuEngineExecutePackage(
+    __in BURN_EXECUTE_ACTION* pExecuteAction,
+    __in BURN_VARIABLES* pVariables,
+    __in BOOL fRollback,
+    __in BOOL fStopWusaService,
+    __in PFN_GENERICMESSAGEHANDLER pfnGenericMessageHandler,
+    __in LPVOID pvContext,
+    __out BOOTSTRAPPER_APPLY_RESTART* pRestart
+    )
+{
+    HRESULT hr = S_OK;
+    int nResult = IDNOACTION;
+    LPWSTR sczCachedDirectory = NULL;
+    LPWSTR sczMsuPath = NULL;
+    LPWSTR sczWindowsPath = NULL;
+    LPWSTR sczSystemPath = NULL;
+    LPWSTR sczWusaPath = NULL;
+    LPWSTR sczCommand = NULL;
+    SC_HANDLE schWu = NULL;
+    BOOL fWuWasDisabled = FALSE;
+    STARTUPINFOW si = { };
+    PROCESS_INFORMATION pi = { };
+    GENERIC_EXECUTE_MESSAGE message = { };
+    DWORD dwExitCode = 0;
+    BOOL fUseSysNativePath = FALSE;
+
+#if !defined(_WIN64)
+    hr = ProcWow64(::GetCurrentProcess(), &fUseSysNativePath);
+    ExitOnFailure(hr, "Failed to determine WOW64 status.");
+#endif
+
+    *pRestart = BOOTSTRAPPER_APPLY_RESTART_NONE;
+
+    // get wusa.exe path
+    if (fUseSysNativePath)
+    {
+        hr = PathGetKnownFolder(CSIDL_WINDOWS, &sczWindowsPath);
+        ExitOnFailure(hr, "Failed to find Windows directory.");
+
+        hr = PathConcat(sczWindowsPath, L"SysNative\\", &sczSystemPath);
+        ExitOnFailure(hr, "Failed to append SysNative directory.");
+    }
+    else
+    {
+        hr = PathGetKnownFolder(CSIDL_SYSTEM, &sczSystemPath);
+        ExitOnFailure(hr, "Failed to find System32 directory.");
+    }
+
+    hr = PathConcat(sczSystemPath, L"wusa.exe", &sczWusaPath);
+    ExitOnFailure(hr, "Failed to allocate WUSA.exe path.");
+
+    // build command
+    switch (pExecuteAction->msuPackage.action)
+    {
+    case BOOTSTRAPPER_ACTION_STATE_INSTALL:
+        // get cached MSU path
+        hr = CacheGetCompletedPath(TRUE, pExecuteAction->msuPackage.pPackage->sczCacheId, &sczCachedDirectory);
+        ExitOnFailure(hr, "Failed to get cached path for package: %ls", pExecuteAction->msuPackage.pPackage->sczId);
+
+        // Best effort to set the execute package cache folder variable.
+        VariableSetString(pVariables, BURN_BUNDLE_EXECUTE_PACKAGE_CACHE_FOLDER, sczCachedDirectory, TRUE);
+
+        hr = PathConcat(sczCachedDirectory, pExecuteAction->msuPackage.pPackage->rgPayloads[0].pPayload->sczFilePath, &sczMsuPath);
+        ExitOnFailure(hr, "Failed to build MSU path.");
+
+        // format command
+        hr = StrAllocFormatted(&sczCommand, L"\"%ls\" \"%ls\" /quiet /norestart", sczWusaPath, sczMsuPath);
+        ExitOnFailure(hr, "Failed to format MSU install command.");
+        break;
+
+    case BOOTSTRAPPER_ACTION_STATE_UNINSTALL:
+        // format command
+        hr = StrAllocFormatted(&sczCommand, L"\"%ls\" /uninstall /kb:%ls /quiet /norestart", sczWusaPath, pExecuteAction->msuPackage.pPackage->Msu.sczKB);
+        ExitOnFailure(hr, "Failed to format MSU uninstall command.");
+        break;
+
+    default:
+        hr = E_UNEXPECTED;
+        ExitOnFailure(hr, "Failed to get action arguments for MSU package.");
+    }
+
+    if (pExecuteAction->msuPackage.sczLogPath && *pExecuteAction->msuPackage.sczLogPath)
+    {
+        hr = StrAllocConcat(&sczCommand, L" /log:", 0);
+        ExitOnFailure(hr, "Failed to append log switch to MSU command-line.");
+
+        hr = StrAllocConcat(&sczCommand, pExecuteAction->msuPackage.sczLogPath, 0);
+        ExitOnFailure(hr, "Failed to append log path to MSU command-line.");
+    }
+
+    LogId(REPORT_STANDARD, MSG_APPLYING_PACKAGE, LoggingRollbackOrExecute(fRollback), pExecuteAction->msuPackage.pPackage->sczId, LoggingActionStateToString(pExecuteAction->msuPackage.action), sczMsuPath ? sczMsuPath : pExecuteAction->msuPackage.pPackage->Msu.sczKB, sczCommand);
+
+    hr = EnsureWUServiceEnabled(fStopWusaService, &schWu, &fWuWasDisabled);
+    ExitOnFailure(hr, "Failed to ensure WU service was enabled to install MSU package.");
+
+    // create process
+    si.cb = sizeof(si);
+    if (!::CreateProcessW(sczWusaPath, sczCommand, NULL, NULL, FALSE, CREATE_NO_WINDOW, NULL, NULL, &si, &pi))
+    {
+        ExitWithLastError(hr, "Failed to CreateProcess on path: %ls", sczWusaPath);
+    }
+
+    do
+    {
+        message.type = GENERIC_EXECUTE_MESSAGE_PROGRESS;
+        message.dwAllowedResults = MB_OKCANCEL;
+        message.progress.dwPercentage = 50;
+        nResult = pfnGenericMessageHandler(&message, pvContext);
+        hr = (IDOK == nResult || IDNOACTION == nResult) ? S_OK : IDCANCEL == nResult ? HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT) : HRESULT_FROM_WIN32(ERROR_INSTALL_FAILURE);
+        ExitOnRootFailure(hr, "Bootstrapper application aborted during MSU progress.");
+
+        // wait for process to terminate
+        hr = ProcWaitForCompletion(pi.hProcess, 500, &dwExitCode);
+        if (HRESULT_FROM_WIN32(WAIT_TIMEOUT) != hr)
+        {
+            ExitOnFailure(hr, "Failed to wait for executable to complete: %ls", sczWusaPath);
+        }
+    } while (HRESULT_FROM_WIN32(WAIT_TIMEOUT) == hr);
+
+    // get process exit code
+    if (!::GetExitCodeProcess(pi.hProcess, &dwExitCode))
+    {
+        ExitWithLastError(hr, "Failed to get process exit code.");
+    }
+
+    // We'll normalize the restart required error code from wusa.exe just in case. Most likely
+    // that on reboot we'll actually get WU_S_REBOOT_REQUIRED.
+    if (HRESULT_FROM_WIN32(ERROR_SUCCESS_REBOOT_REQUIRED) == static_cast<HRESULT>(dwExitCode))
+    {
+        dwExitCode = ERROR_SUCCESS_REBOOT_REQUIRED;
+    }
+
+    // handle exit code
+    switch (dwExitCode)
+    {
+    case S_OK: __fallthrough;
+    case S_FALSE: __fallthrough;
+    case WU_S_ALREADY_INSTALLED:
+        hr = S_OK;
+        break;
+
+    case ERROR_SUCCESS_REBOOT_REQUIRED: __fallthrough;
+    case WU_S_REBOOT_REQUIRED:
+        *pRestart = BOOTSTRAPPER_APPLY_RESTART_REQUIRED;
+        hr = S_OK;
+        break;
+
+    default:
+        hr = static_cast<HRESULT>(dwExitCode);
+        break;
+    }
+
+LExit:
+    ReleaseStr(sczCachedDirectory);
+    ReleaseStr(sczMsuPath);
+    ReleaseStr(sczSystemPath);
+    ReleaseStr(sczWindowsPath);
+    ReleaseStr(sczWusaPath);
+    ReleaseStr(sczCommand);
+
+    ReleaseHandle(pi.hProcess);
+    ReleaseHandle(pi.hThread);
+
+    if (fWuWasDisabled)
+    {
+        SetServiceStartType(schWu, SERVICE_DISABLED);
+    }
+
+    // Best effort to clear the execute package cache folder variable.
+    VariableSetString(pVariables, BURN_BUNDLE_EXECUTE_PACKAGE_CACHE_FOLDER, NULL, TRUE);
+
+    return hr;
+}
+
+static HRESULT EnsureWUServiceEnabled(
+    __in BOOL fStopWusaService,
+    __out SC_HANDLE* pschWu,
+    __out BOOL* pfPreviouslyDisabled
+    )
+{
+    HRESULT hr = S_OK;
+    SC_HANDLE schSCM = NULL;
+    SC_HANDLE schWu = NULL;
+    SERVICE_STATUS serviceStatus = { };
+    QUERY_SERVICE_CONFIGW* pConfig = NULL;
+
+    schSCM = ::OpenSCManagerW(NULL, NULL, SC_MANAGER_ALL_ACCESS);
+    ExitOnNullWithLastError(schSCM, hr, "Failed to open service control manager.");
+
+    schWu = ::OpenServiceW(schSCM, L"wuauserv", SERVICE_QUERY_CONFIG | SERVICE_CHANGE_CONFIG | SERVICE_QUERY_STATUS | SERVICE_STOP );
+    ExitOnNullWithLastError(schWu, hr, "Failed to open WU service.");
+
+    if (!::QueryServiceStatus(schWu, &serviceStatus) )
+    {
+        ExitWithLastError(hr, "Failed to query status of WU service.");
+    }
+
+    // Stop service if requested to.
+    if (SERVICE_STOPPED != serviceStatus.dwCurrentState && fStopWusaService)
+    {
+        hr = StopWUService(schWu);
+    }
+
+    // If the service is not running then it might be disabled so let's check.
+    if (SERVICE_RUNNING != serviceStatus.dwCurrentState)
+    {
+        hr = SvcQueryConfig(schWu, &pConfig);
+        ExitOnFailure(hr, "Failed to read configuration for WU service.");
+
+        // If WU is disabled, change it to a demand start service (but touch nothing else).
+        if (SERVICE_DISABLED == pConfig->dwStartType)
+        {
+            hr = SetServiceStartType(schWu, SERVICE_DEMAND_START);
+            ExitOnFailure(hr, "Failed to mark WU service to start on demand.");
+
+            *pfPreviouslyDisabled = TRUE;
+        }
+    }
+
+    *pschWu = schWu;
+    schWu = NULL;
+
+LExit:
+    ReleaseMem(pConfig);
+    ReleaseServiceHandle(schWu);
+    ReleaseServiceHandle(schSCM);
+
+    return hr;
+}
+
+static HRESULT SetServiceStartType(
+    __in SC_HANDLE sch,
+    __in DWORD startType
+    )
+{
+    HRESULT hr = S_OK;
+
+    if (!::ChangeServiceConfigW(sch, SERVICE_NO_CHANGE, startType, SERVICE_NO_CHANGE, NULL, NULL, NULL, NULL, NULL, NULL, NULL))
+    {
+        ExitWithLastError(hr, "Failed to set service start type.");
+    }
+
+LExit:
+    return hr;
+}
+
+static HRESULT StopWUService(
+    __in SC_HANDLE schWu
+    )
+{
+    HRESULT hr = S_OK;
+    SERVICE_STATUS serviceStatus = { };
+
+    if(!::ControlService(schWu, SERVICE_CONTROL_STOP, &serviceStatus))
+    {
+        ExitWithLastError(hr, "Failed to stop wusa service.");
+    }
+
+LExit:
+    return hr;
+}
diff --git a/src/engine/msuengine.h b/src/engine/msuengine.h
new file mode 100644
index 00000000..d0323b06
--- /dev/null
+++ b/src/engine/msuengine.h
@@ -0,0 +1,48 @@
+#pragma once
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+
+// function declarations
+
+HRESULT MsuEngineParsePackageFromXml(
+    __in IXMLDOMNode* pixnMsiPackage,
+    __in BURN_PACKAGE* pPackage
+    );
+void MsuEnginePackageUninitialize(
+    __in BURN_PACKAGE* pPackage
+    );
+HRESULT MsuEngineDetectPackage(
+    __in BURN_PACKAGE* pPackage,
+    __in BURN_VARIABLES* pVariables
+    );
+HRESULT MsuEnginePlanCalculatePackage(
+    __in BURN_PACKAGE* pPackage,
+    __out_opt BOOL* pfBARequestedCache
+    );
+HRESULT MsuEnginePlanAddPackage(
+    __in BURN_PACKAGE* pPackage,
+    __in BURN_PLAN* pPlan,
+    __in BURN_LOGGING* pLog,
+    __in BURN_VARIABLES* pVariables,
+    __in HANDLE hCacheEvent,
+    __in BOOL fPlanPackageCacheRollback
+    );
+HRESULT MsuEngineExecutePackage(
+    __in BURN_EXECUTE_ACTION* pExecuteAction,
+    __in BURN_VARIABLES* pVariables,
+    __in BOOL fRollback,
+    __in BOOL fStopWusaService,
+    __in PFN_GENERICMESSAGEHANDLER pfnGenericMessageHandler,
+    __in LPVOID pvContext,
+    __out BOOTSTRAPPER_APPLY_RESTART* pRestart
+    );
+
+
+#if defined(__cplusplus)
+}
+#endif
diff --git a/src/engine/netfxchainer.cpp b/src/engine/netfxchainer.cpp
new file mode 100644
index 00000000..4e7a7720
--- /dev/null
+++ b/src/engine/netfxchainer.cpp
@@ -0,0 +1,418 @@
+// 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.
+
+#include "precomp.h"
+
+static VOID DestroyNetFxChainer(
+    __in NetFxChainer* pChainer
+    )
+{
+    if (pChainer)
+    {
+        ReleaseHandle(pChainer->hSection);
+        ReleaseHandle(pChainer->hEventChaineeSend);
+        ReleaseHandle(pChainer->hEventChainerSend);
+        ReleaseHandle(pChainer->hMutex);
+
+        if (pChainer->pData)
+        {
+            ::UnmapViewOfFile(pChainer->pData);
+        }
+
+        MemFree(pChainer);
+    }
+}
+
+static HRESULT CreateNetFxChainer(
+    __in LPCWSTR wzSectionName, 
+    __in LPCWSTR wzEventName, 
+    __out NetFxChainer** ppChainer
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR sczName = NULL;
+    NetFxChainer* pChainer = NULL;
+
+    pChainer = (NetFxChainer*)MemAlloc(sizeof(NetFxChainer), TRUE);
+    ExitOnNull(pChainer, hr, E_OUTOFMEMORY, "Failed to allocate memory for NetFxChainer struct.");
+
+    pChainer->hEventChaineeSend = ::CreateEvent(NULL, FALSE, FALSE, wzEventName);
+    ExitOnNullWithLastError(pChainer->hEventChaineeSend, hr, "Failed to create event: %ls", wzEventName);
+
+    hr = StrAllocFormatted(&sczName, L"%ls_send", wzEventName);
+    ExitOnFailure(hr, "failed to allocate memory for event name");
+
+    pChainer->hEventChainerSend = ::CreateEvent(NULL, FALSE, FALSE, sczName);
+    ExitOnNullWithLastError(pChainer->hEventChainerSend, hr, "Failed to create event: %ls", sczName);
+
+    hr = StrAllocFormatted(&sczName, L"%ls_mutex", wzEventName);
+    ExitOnFailure(hr, "failed to allocate memory for mutex name");
+
+    // Create the mutex, we initially own
+    pChainer->hMutex = ::CreateMutex(NULL, TRUE, sczName);
+    ExitOnNullWithLastError(pChainer->hMutex, hr, "Failed to create mutex: %ls", sczName);
+
+    pChainer->hSection = ::CreateFileMapping(INVALID_HANDLE_VALUE,
+                                   NULL, // security attributes
+                                   PAGE_READWRITE,
+                                   0, // high-order DWORD of maximum size
+                                   NETFXDATA_SIZE, // low-order DWORD of maximum size
+                                   wzSectionName);
+    ExitOnNullWithLastError(pChainer->hSection, hr, "Failed to memory map cabinet file: %ls", wzSectionName);
+
+    pChainer->pData = reinterpret_cast<NetFxDataStructure*>(::MapViewOfFile(pChainer->hSection,
+                                                                          FILE_MAP_WRITE,
+                                                                          0, 0, // offsets
+                                                                          0 // map entire file
+                                                                          ));
+    ExitOnNullWithLastError(pChainer->pData, hr, "Failed to MapViewOfFile for %ls.", wzSectionName);
+
+    // Initialize the shared memory
+    hr = ::StringCchCopyW(pChainer->pData->szEventName, countof(pChainer->pData->szEventName), wzEventName);
+    ExitOnFailure(hr, "failed to copy event name to shared memory structure.");
+    pChainer->pData->downloadFinished = false;
+    pChainer->pData->downloadSoFar = 0;
+    pChainer->pData->hrDownloadFinished = E_PENDING;
+    pChainer->pData->downloadAbort = false;
+    pChainer->pData->installFinished = false;
+    pChainer->pData->installSoFar = 0;
+    pChainer->pData->hrInstallFinished = E_PENDING;
+    pChainer->pData->installAbort = false;
+    pChainer->pData->hrInternalError = S_OK;
+    pChainer->pData->version = NETFXDATA_VERSION;
+    pChainer->pData->messageCode = 0;
+    pChainer->pData->messageResponse = 0;
+    pChainer->pData->messageDataLength = 0;
+
+    // Done with initialization, allow others to access.
+    ::ReleaseMutex(pChainer->hMutex);
+
+    *ppChainer = pChainer;
+    pChainer = NULL;
+
+LExit:
+    ReleaseStr(sczName);
+
+    if (pChainer)
+    {
+        // Something failed, release the mutex and destroy the object
+        if (pChainer->hMutex)
+        {
+            ::ReleaseMutex(pChainer->hMutex);
+        }
+
+        DestroyNetFxChainer(pChainer);
+    }
+
+    return  hr;
+}
+
+
+static VOID NetFxAbort(
+    __in NetFxChainer* pChainer
+    )
+{
+    ::WaitForSingleObject(pChainer->hMutex, INFINITE);
+
+    pChainer->pData->downloadAbort = true;
+    pChainer->pData->installAbort = true;
+
+    ::ReleaseMutex(pChainer->hMutex);
+
+    ::SetEvent(pChainer->hEventChainerSend);
+}
+
+static BYTE NetFxGetProgress(
+    __in NetFxChainer* pChainer
+    )
+{
+    BYTE bProgress = 0;
+    ::WaitForSingleObject(pChainer->hMutex, INFINITE);
+
+    bProgress = (pChainer->pData->installSoFar + pChainer->pData->downloadSoFar) / 2;
+
+    ::ReleaseMutex(pChainer->hMutex);
+
+    return bProgress;
+}
+
+static HRESULT NetFxGetMessage(
+    __in NetFxChainer* pChainer,
+    __out DWORD* pdwMessage, 
+    __out LPVOID* ppBuffer, 
+    __out DWORD* pdwBufferSize
+    )
+{
+    HRESULT hr = S_OK;
+    ::WaitForSingleObject(pChainer->hMutex, INFINITE);
+
+    *pdwMessage = pChainer->pData->messageCode;
+    *ppBuffer = NULL;
+    *pdwBufferSize = 0;
+
+    if (NETFX_NO_MESSAGE != *pdwMessage)
+    {
+        *ppBuffer = MemAlloc(pChainer->pData->messageDataLength, TRUE);
+        ExitOnNull(*ppBuffer, hr, E_OUTOFMEMORY, "Failed to allocate memory for message data");
+
+        memcpy(*ppBuffer, pChainer->pData->messageData, pChainer->pData->messageDataLength);
+        *pdwBufferSize = pChainer->pData->messageDataLength;
+    }
+
+LExit:
+    ::ReleaseMutex(pChainer->hMutex);
+
+    return hr;
+}
+
+static void NetFxRespond(
+    __in NetFxChainer* pChainer,
+    __in DWORD dwResponse
+    )
+{
+    ::WaitForSingleObject(pChainer->hMutex, INFINITE);
+
+    pChainer->pData->messageCode = NETFX_NO_MESSAGE;
+    pChainer->pData->messageResponse = dwResponse;
+    if (IDCANCEL == dwResponse)
+    {
+        pChainer->pData->downloadAbort = true;
+        pChainer->pData->installAbort = true;
+    }
+
+    ::ReleaseMutex(pChainer->hMutex);
+
+    ::SetEvent(pChainer->hEventChainerSend);
+}
+
+static HRESULT NetFxGetResult(
+    __in NetFxChainer* pChainer,
+    __out HRESULT* phrInternalError
+    )
+{
+    HRESULT hr = S_OK;
+    ::WaitForSingleObject(pChainer->hMutex, INFINITE);
+
+    hr = pChainer->pData->hrInstallFinished;
+
+    if (FAILED(pChainer->pData->hrDownloadFinished) && // Download failed
+       (S_OK == hr || E_ABORT == hr))                  // Install succeeded or was aborted
+    {
+        hr = pChainer->pData->hrDownloadFinished;
+    }
+
+    if (phrInternalError)
+    {
+        *phrInternalError = pChainer->pData->hrInternalError;
+    }
+
+    ::ReleaseMutex(pChainer->hMutex);
+
+    return hr;
+}
+
+static HRESULT OnNetFxFilesInUse(
+    __in NetFxChainer* pNetfxChainer,
+    __in NetFxCloseApplications* pCloseApps,
+    __in PFN_GENERICMESSAGEHANDLER pfnMessageHandler,
+    __in LPVOID pvContext
+    )
+{
+    HRESULT hr = S_OK;
+    DWORD cFiles = 0;
+    LPWSTR* rgwzFiles = NULL;
+    GENERIC_EXECUTE_MESSAGE message = { };
+    DWORD dwResponse = 0;
+
+    cFiles = pCloseApps->dwApplicationsSize;
+    rgwzFiles = (LPWSTR*)MemAlloc(sizeof(LPWSTR*) * cFiles, TRUE);
+    ExitOnNull(rgwzFiles, hr, E_OUTOFMEMORY, "Failed to allocate buffer.");
+
+    for (DWORD i = 0; i < pCloseApps->dwApplicationsSize; ++i)
+    {
+        rgwzFiles[i] = pCloseApps->applications[i].szName;
+    }
+
+    // send message
+    message.type = GENERIC_EXECUTE_MESSAGE_FILES_IN_USE;
+    message.dwAllowedResults = MB_ABORTRETRYIGNORE;
+    message.filesInUse.cFiles = cFiles;
+    message.filesInUse.rgwzFiles = (LPCWSTR*)rgwzFiles;
+    dwResponse = (DWORD)pfnMessageHandler(&message, pvContext);
+
+    NetFxRespond(pNetfxChainer, dwResponse);
+
+LExit:
+    ReleaseMem(rgwzFiles);
+
+    return hr;
+}
+
+static HRESULT OnNetFxProgress(
+    __in NetFxChainer* pNetfxChainer,
+    __in BYTE bProgress,
+    __in PFN_GENERICMESSAGEHANDLER pfnMessageHandler,
+    __in LPVOID pvContext
+    )
+{
+    GENERIC_EXECUTE_MESSAGE message = { };
+    DWORD dwResponse = 0;
+
+    // send message
+    message.type = GENERIC_EXECUTE_MESSAGE_PROGRESS;
+    message.dwAllowedResults = MB_OKCANCEL;
+    message.progress.dwPercentage = 100 * (DWORD)bProgress / BYTE_MAX;
+    dwResponse = (DWORD)pfnMessageHandler(&message, pvContext);
+
+    if (IDCANCEL == dwResponse)
+    {
+        NetFxAbort(pNetfxChainer);
+    }
+
+    return S_OK;
+}
+
+static HRESULT OnNetFxError(
+    __in NetFxChainer* /*pNetfxChainer*/,
+    __in HRESULT hrError,
+    __in PFN_GENERICMESSAGEHANDLER pfnMessageHandler,
+    __in LPVOID pvContext
+    )
+{
+    GENERIC_EXECUTE_MESSAGE message = { };
+    DWORD dwResponse = 0;
+
+    // send message
+    message.type = GENERIC_EXECUTE_MESSAGE_ERROR;
+    message.dwAllowedResults = MB_OK;
+    message.error.dwErrorCode = hrError;
+    message.error.wzMessage = NULL;
+    dwResponse = (DWORD)pfnMessageHandler(&message, pvContext);
+
+    return S_OK;
+}
+
+static HRESULT ProcessNetFxMessage(
+    __in NetFxChainer* pNetfxChainer,
+    __in PFN_GENERICMESSAGEHANDLER pfnGenericMessageHandler,
+    __in LPVOID pvContext
+    )
+{
+    HRESULT hr = S_OK;
+    DWORD dwMessage = NETFX_NO_MESSAGE;
+    DWORD dwBufferSize = 0;
+    LPVOID pBuffer = NULL;
+
+    // send progress
+    hr = OnNetFxProgress(pNetfxChainer, NetFxGetProgress(pNetfxChainer), pfnGenericMessageHandler, pvContext);
+    ExitOnFailure(hr, "Failed to send progress from netfx chainer.");
+
+    // Check for message
+    hr = NetFxGetMessage(pNetfxChainer, &dwMessage, &pBuffer, &dwBufferSize);
+    ExitOnFailure(hr, "Failed to get message from netfx chainer.");
+
+    switch(dwMessage)
+    {
+    case NETFX_CLOSE_APPS:
+        hr = OnNetFxFilesInUse(pNetfxChainer, (NetFxCloseApplications*)pBuffer, pfnGenericMessageHandler, pvContext);
+        ExitOnFailure(hr, "Failed to send files in use message from netfx chainer.");
+        break;
+
+    default:
+        // No message we understand.
+        break;
+    }
+
+LExit:
+    ReleaseMem(pBuffer);
+
+    return hr;
+}
+
+extern "C" HRESULT NetFxRunChainer(
+    __in LPCWSTR wzExecutablePath,
+    __in LPCWSTR wzArguments,
+    __in PFN_GENERICMESSAGEHANDLER pfnGenericMessageHandler,
+    __in LPVOID pvContext,
+    __out DWORD* pdwExitCode
+    )
+{
+    HRESULT hr = S_OK;
+    DWORD er = 0;
+    WCHAR wzGuid[GUID_STRING_LENGTH];
+    LPWSTR sczEventName = NULL;
+    LPWSTR sczSectionName = NULL;
+    LPWSTR sczCommand = NULL;
+    NetFxChainer* pNetfxChainer = NULL;
+    STARTUPINFOW si = { };
+    PROCESS_INFORMATION pi = { };
+    HRESULT hrInternalError = 0;
+
+    // Create the unique name suffix.
+    hr = GuidFixedCreate(wzGuid);
+    ExitOnRootFailure(hr, "Failed to create netfx chainer guid.");
+
+    hr = StrAllocFormatted(&sczSectionName, L"NetFxSection.%ls", wzGuid);
+    ExitOnFailure(hr, "Failed to allocate section name.");
+
+    hr = StrAllocFormatted(&sczEventName, L"NetFxEvent.%ls", wzGuid);
+    ExitOnFailure(hr, "Failed to allocate event name.");
+
+    hr = CreateNetFxChainer(sczSectionName, sczEventName, &pNetfxChainer);
+    ExitOnFailure(hr, "Failed to create netfx chainer.");
+
+    hr = StrAllocFormattedSecure(&sczCommand, L"%ls /pipe %ls", wzArguments, sczSectionName);
+    ExitOnFailure(hr, "Failed to allocate netfx chainer arguments.");
+
+    si.cb = sizeof(si);
+    if (!::CreateProcessW(wzExecutablePath, sczCommand, NULL, NULL, FALSE, CREATE_NO_WINDOW, NULL, NULL, &si, &pi))
+    {
+        ExitWithLastError(hr, "Failed to CreateProcess on path: %ls", wzExecutablePath);
+    }
+
+    HANDLE handles[2] = { pi.hProcess, pNetfxChainer->hEventChaineeSend };
+
+    for (;;)
+    {
+        er = ::WaitForMultipleObjects(2, handles, FALSE, 100);
+        if (WAIT_OBJECT_0 == er)
+        {
+            // Process has exited
+            *pdwExitCode = NetFxGetResult(pNetfxChainer, &hrInternalError);
+            if (E_PENDING == *pdwExitCode)
+            {
+                if (!::GetExitCodeProcess(pi.hProcess, pdwExitCode))
+                {
+                    ExitWithLastError(hr, "Failed to get netfx return code.");
+                }
+            }
+            else if (FAILED(hrInternalError))
+            {
+                // push internal error message
+                OnNetFxError(pNetfxChainer, hrInternalError, pfnGenericMessageHandler, pvContext);
+                ExitOnFailure(hr, "Failed to send internal error message from netfx chainer.");
+            }           
+
+            break;
+        }
+        else if (WAIT_OBJECT_0 + 1 == er)
+        {
+            // Chainee has notified us of a change.
+            hr = ProcessNetFxMessage(pNetfxChainer, pfnGenericMessageHandler, pvContext);
+            ExitOnFailure(hr, "Failed to process netfx chainer message.");
+        }
+        else if (WAIT_FAILED == er)
+        {
+            ExitWithLastError(hr, "Failed to wait for netfx chainer process to complete");
+        }
+    }
+
+LExit:
+    ReleaseStr(sczSectionName);
+    ReleaseStr(sczEventName);
+    StrSecureZeroFreeString(sczCommand);
+    DestroyNetFxChainer(pNetfxChainer);
+    ReleaseHandle(pi.hThread);
+    ReleaseHandle(pi.hProcess);
+
+    return hr;
+}
diff --git a/src/engine/netfxchainer.h b/src/engine/netfxchainer.h
new file mode 100644
index 00000000..7d3aff1c
--- /dev/null
+++ b/src/engine/netfxchainer.h
@@ -0,0 +1,98 @@
+#pragma once
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+struct NetFxDataStructure
+{
+    bool downloadFinished;               // download done yet?
+    bool installFinished;                // install done yet?
+    bool downloadAbort;                  // set downloader to abort
+    bool installAbort;                   // set installer to abort
+    HRESULT hrDownloadFinished;          // resultant HRESULT for download
+    HRESULT hrInstallFinished;           // resultant HRESULT for install
+    HRESULT hrInternalError;
+    WCHAR szCurrentItemStep[MAX_PATH];
+    BYTE downloadSoFar;         // download progress 0 - 255 (0 to 100% done) 
+    BYTE installSoFar;          // install progress 0 - 255 (0 to 100% done)
+    WCHAR szEventName[MAX_PATH];         // event that chainer 'creates' and chainee 'opens'to sync communications
+
+    BYTE version;                        // version of the data structure, set by chainer.
+
+    DWORD messageCode;                   // current message being sent by the chainee, 0 if no message is active
+    DWORD messageResponse;               // chainer's response to current message, 0 if not yet handled
+    DWORD messageDataLength;             // length of the m_messageData field in bytes
+    BYTE messageData[1];                 // variable length buffer, content depends on m_messageCode
+};
+
+struct NetFxChainer
+{
+    HANDLE hSection;
+
+    HANDLE hEventChaineeSend;
+    HANDLE hEventChainerSend;
+    HANDLE hMutex;
+
+    NetFxDataStructure* pData;
+    DWORD dwDataSize;
+};
+
+#define NETFXDATA_SIZE           65536
+
+#define NETFXDATA_VERSION        1
+
+#define NETFX_MESSAGE(version, defaultResponse, messageCode) \
+    ((((DWORD)version & 0xFF) << 24) | (((DWORD)defaultResponse & 0xFF) << 16) | ((DWORD)messageCode & 0xFFFF))
+#define NETFX_MESSAGE_CODE(messageId) \
+    (messageId & 0xFFFF)
+#define NETFX_MESSAGE_DEFAULT_RESPONSE(messageId) \
+    ((messageId >> 16) & 0xFF)
+#define NETFX_MESSAGE_VERSION(messageId) \
+    ((messageId >>24) & 0xFF)
+
+#define NETFX_NO_MESSAGE    0
+
+
+//------------------------------------------------------------------------------
+// NETFX_CLOSE_APPS
+//
+// Sent by the chainee when it detects that applications are holding files in 
+// use.  Respond to this message in order to tell the chainee to close the 
+// applications to prevent a reboot.
+//
+// pData : NetFxCloseApplications : The list of applications
+// Acceptable responses:
+//   IDYES   : Indicates that the chainee should attempt to shutdown the apps.
+//             If all apps do not successfully close the message may be sent again.
+//   IDNO    : Indicates that the chainee should not attempt to close apps.
+//   IDRETRY : Indicates that the chainee should refresh the list of apps.
+//             Another NETFX_CLOSE_APPS message will be sent asynchronously with
+//             the new list of apps.
+//------------------------------------------------------------------------------
+#define NETFX_CLOSE_APPS    NETFX_MESSAGE(NETFXDATA_VERSION, IDNO, 1)
+
+struct NetFxApplication
+{
+    WCHAR szName[MAX_PATH];
+    DWORD dwPid;
+};
+
+struct NetFxCloseApplications
+{
+    DWORD dwApplicationsSize;
+    NetFxApplication applications[1];
+};
+
+HRESULT NetFxRunChainer(
+    __in LPCWSTR wzExecutablePath,
+    __in LPCWSTR wzArguments,
+    __in PFN_GENERICMESSAGEHANDLER pfnGenericMessageHandler,
+    __in LPVOID pvContext,
+    __out DWORD* pdwExitCode
+    );
+#if defined(__cplusplus)
+}
+#endif
diff --git a/src/engine/package.cpp b/src/engine/package.cpp
new file mode 100644
index 00000000..02958efd
--- /dev/null
+++ b/src/engine/package.cpp
@@ -0,0 +1,678 @@
+// 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.
+
+#include "precomp.h"
+
+
+// internal function declarations
+
+static HRESULT ParsePayloadRefsFromXml(
+    __in BURN_PACKAGE* pPackage,
+    __in BURN_PAYLOADS* pPayloads,
+    __in IXMLDOMNode* pixnPackage
+    );
+static HRESULT ParsePatchTargetCode(
+    __in BURN_PACKAGES* pPackages,
+    __in IXMLDOMNode* pixnBundle
+    );
+static HRESULT FindRollbackBoundaryById(
+    __in BURN_PACKAGES* pPackages,
+    __in_z LPCWSTR wzId,
+    __out BURN_ROLLBACK_BOUNDARY** ppRollbackBoundary
+    );
+
+
+// function definitions
+
+extern "C" HRESULT PackagesParseFromXml(
+    __in BURN_PACKAGES* pPackages,
+    __in BURN_PAYLOADS* pPayloads,
+    __in IXMLDOMNode* pixnBundle
+    )
+{
+    HRESULT hr = S_OK;
+    IXMLDOMNodeList* pixnNodes = NULL;
+    IXMLDOMNode* pixnNode = NULL;
+    DWORD cNodes = 0;
+    BSTR bstrNodeName = NULL;
+    DWORD cMspPackages = 0;
+    LPWSTR scz = NULL;
+
+    // select rollback boundary nodes
+    hr = XmlSelectNodes(pixnBundle, L"RollbackBoundary", &pixnNodes);
+    ExitOnFailure(hr, "Failed to select rollback boundary nodes.");
+
+    // get rollback boundary node count
+    hr = pixnNodes->get_length((long*)&cNodes);
+    ExitOnFailure(hr, "Failed to get rollback bundary node count.");
+
+    if (cNodes)
+    {
+        // allocate memory for rollback boundaries
+        pPackages->rgRollbackBoundaries = (BURN_ROLLBACK_BOUNDARY*)MemAlloc(sizeof(BURN_ROLLBACK_BOUNDARY) * cNodes, TRUE);
+        ExitOnNull(pPackages->rgRollbackBoundaries, hr, E_OUTOFMEMORY, "Failed to allocate memory for rollback boundary structs.");
+
+        pPackages->cRollbackBoundaries = cNodes;
+
+        // parse rollback boundary elements
+        for (DWORD i = 0; i < cNodes; ++i)
+        {
+            BURN_ROLLBACK_BOUNDARY* pRollbackBoundary = &pPackages->rgRollbackBoundaries[i];
+
+            hr = XmlNextElement(pixnNodes, &pixnNode, &bstrNodeName);
+            ExitOnFailure(hr, "Failed to get next node.");
+
+            // @Id
+            hr = XmlGetAttributeEx(pixnNode, L"Id", &pRollbackBoundary->sczId);
+            ExitOnFailure(hr, "Failed to get @Id.");
+
+            // @Vital
+            hr = XmlGetYesNoAttribute(pixnNode, L"Vital", &pRollbackBoundary->fVital);
+            ExitOnFailure(hr, "Failed to get @Vital.");
+
+            // @Transaction
+            hr = XmlGetYesNoAttribute(pixnNode, L"Transaction", &pRollbackBoundary->fTransaction);
+            ExitOnFailure(hr, "Failed to get @Transaction.");
+
+            // prepare next iteration
+            ReleaseNullObject(pixnNode);
+            ReleaseNullBSTR(bstrNodeName);
+        }
+    }
+
+    ReleaseNullObject(pixnNodes); // done with the RollbackBoundary elements.
+
+    // select package nodes
+    hr = XmlSelectNodes(pixnBundle, L"Chain/ExePackage|Chain/MsiPackage|Chain/MspPackage|Chain/MsuPackage", &pixnNodes);
+    ExitOnFailure(hr, "Failed to select package nodes.");
+
+    // get package node count
+    hr = pixnNodes->get_length((long*)&cNodes);
+    ExitOnFailure(hr, "Failed to get package node count.");
+
+    if (!cNodes)
+    {
+        ExitFunction1(hr = S_OK);
+    }
+
+    // allocate memory for packages
+    pPackages->rgPackages = (BURN_PACKAGE*)MemAlloc(sizeof(BURN_PACKAGE) * cNodes, TRUE);
+    ExitOnNull(pPackages->rgPackages, hr, E_OUTOFMEMORY, "Failed to allocate memory for package structs.");
+
+    pPackages->cPackages = cNodes;
+
+    // parse package elements
+    for (DWORD i = 0; i < cNodes; ++i)
+    {
+        BURN_PACKAGE* pPackage = &pPackages->rgPackages[i];
+
+        hr = XmlNextElement(pixnNodes, &pixnNode, &bstrNodeName);
+        ExitOnFailure(hr, "Failed to get next node.");
+
+        // @Id
+        hr = XmlGetAttributeEx(pixnNode, L"Id", &pPackage->sczId);
+        ExitOnFailure(hr, "Failed to get @Id.");
+
+        // @Cache
+        hr = XmlGetAttributeEx(pixnNode, L"Cache", &scz);
+        if (SUCCEEDED(hr))
+        {
+            if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, scz, -1, L"no", -1))
+            {
+                pPackage->cacheType = BURN_CACHE_TYPE_NO;
+            }
+            else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, scz, -1, L"yes", -1))
+            {
+                pPackage->cacheType = BURN_CACHE_TYPE_YES;
+            }
+            else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, scz, -1, L"always", -1))
+            {
+                pPackage->cacheType = BURN_CACHE_TYPE_ALWAYS;
+            }
+            else
+            {
+                hr = E_UNEXPECTED;
+                ExitOnFailure(hr, "Invalid cache type: %ls", scz);
+            }
+        }
+        ExitOnFailure(hr, "Failed to get @Cache.");
+
+        // @CacheId
+        hr = XmlGetAttributeEx(pixnNode, L"CacheId", &pPackage->sczCacheId);
+        ExitOnFailure(hr, "Failed to get @CacheId.");
+
+        // @Size
+        hr = XmlGetAttributeLargeNumber(pixnNode, L"Size", &pPackage->qwSize);
+        ExitOnFailure(hr, "Failed to get @Size.");
+
+        // @InstallSize
+        hr = XmlGetAttributeLargeNumber(pixnNode, L"InstallSize", &pPackage->qwInstallSize);
+        ExitOnFailure(hr, "Failed to get @InstallSize.");
+
+        // @PerMachine
+        hr = XmlGetYesNoAttribute(pixnNode, L"PerMachine", &pPackage->fPerMachine);
+        ExitOnFailure(hr, "Failed to get @PerMachine.");
+
+        // @Permanent
+        hr = XmlGetYesNoAttribute(pixnNode, L"Permanent", &pPackage->fUninstallable);
+        ExitOnFailure(hr, "Failed to get @Permanent.");
+        pPackage->fUninstallable = !pPackage->fUninstallable; // TODO: change "Uninstallable" variable name to permanent, until then Uninstallable is the opposite of Permanent so fix the variable.
+
+        // @Vital
+        hr = XmlGetYesNoAttribute(pixnNode, L"Vital", &pPackage->fVital);
+        ExitOnFailure(hr, "Failed to get @Vital.");
+
+        // @LogPathVariable
+        hr = XmlGetAttributeEx(pixnNode, L"LogPathVariable", &pPackage->sczLogPathVariable);
+        if (E_NOTFOUND != hr)
+        {
+            ExitOnFailure(hr, "Failed to get @LogPathVariable.");
+        }
+
+        // @RollbackLogPathVariable
+        hr = XmlGetAttributeEx(pixnNode, L"RollbackLogPathVariable", &pPackage->sczRollbackLogPathVariable);
+        if (E_NOTFOUND != hr)
+        {
+            ExitOnFailure(hr, "Failed to get @RollbackLogPathVariable.");
+        }
+
+        // @InstallCondition
+        hr = XmlGetAttributeEx(pixnNode, L"InstallCondition", &pPackage->sczInstallCondition);
+        if (E_NOTFOUND != hr)
+        {
+            ExitOnFailure(hr, "Failed to get @InstallCondition.");
+        }
+
+        // @RollbackBoundaryForward
+        hr = XmlGetAttributeEx(pixnNode, L"RollbackBoundaryForward", &scz);
+        if (E_NOTFOUND != hr)
+        {
+            ExitOnFailure(hr, "Failed to get @RollbackBoundaryForward.");
+
+            hr =  FindRollbackBoundaryById(pPackages, scz, &pPackage->pRollbackBoundaryForward);
+            ExitOnFailure(hr, "Failed to find forward transaction boundary: %ls", scz);
+        }
+
+        // @RollbackBoundaryBackward
+        hr = XmlGetAttributeEx(pixnNode, L"RollbackBoundaryBackward", &scz);
+        if (E_NOTFOUND != hr)
+        {
+            ExitOnFailure(hr, "Failed to get @RollbackBoundaryBackward.");
+
+            hr =  FindRollbackBoundaryById(pPackages, scz, &pPackage->pRollbackBoundaryBackward);
+            ExitOnFailure(hr, "Failed to find backward transaction boundary: %ls", scz);
+        }
+
+        // read type specific attributes
+        if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, bstrNodeName, -1, L"ExePackage", -1))
+        {
+            pPackage->type = BURN_PACKAGE_TYPE_EXE;
+
+            hr = ExeEngineParsePackageFromXml(pixnNode, pPackage); // TODO: Modularization
+            ExitOnFailure(hr, "Failed to parse EXE package.");
+        }
+        else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, bstrNodeName, -1, L"MsiPackage", -1))
+        {
+            pPackage->type = BURN_PACKAGE_TYPE_MSI;
+
+            hr = MsiEngineParsePackageFromXml(pixnNode, pPackage); // TODO: Modularization
+            ExitOnFailure(hr, "Failed to parse MSI package.");
+        }
+        else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, bstrNodeName, -1, L"MspPackage", -1))
+        {
+            pPackage->type = BURN_PACKAGE_TYPE_MSP;
+
+            hr = MspEngineParsePackageFromXml(pixnNode, pPackage); // TODO: Modularization
+            ExitOnFailure(hr, "Failed to parse MSP package.");
+
+            ++cMspPackages;
+        }
+        else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, bstrNodeName, -1, L"MsuPackage", -1))
+        {
+            pPackage->type = BURN_PACKAGE_TYPE_MSU;
+
+            hr = MsuEngineParsePackageFromXml(pixnNode, pPackage); // TODO: Modularization
+            ExitOnFailure(hr, "Failed to parse MSU package.");
+        }
+        else
+        {
+            // ignore other package types for now
+        }
+
+        // parse payload references
+        hr = ParsePayloadRefsFromXml(pPackage, pPayloads, pixnNode);
+        ExitOnFailure(hr, "Failed to parse payload references.");
+
+        // parse dependency providers
+        hr = DependencyParseProvidersFromXml(pPackage, pixnNode);
+        ExitOnFailure(hr, "Failed to parse dependency providers.");
+
+        // prepare next iteration
+        ReleaseNullObject(pixnNode);
+        ReleaseNullBSTR(bstrNodeName);
+    }
+
+    if (cMspPackages)
+    {
+        pPackages->rgPatchInfo = static_cast<MSIPATCHSEQUENCEINFOW*>(MemAlloc(sizeof(MSIPATCHSEQUENCEINFOW) * cMspPackages, TRUE));
+        ExitOnNull(pPackages->rgPatchInfo, hr, E_OUTOFMEMORY, "Failed to allocate memory for MSP patch sequence information.");
+
+        pPackages->rgPatchInfoToPackage = static_cast<BURN_PACKAGE**>(MemAlloc(sizeof(BURN_PACKAGE*) * cMspPackages, TRUE));
+        ExitOnNull(pPackages->rgPatchInfoToPackage, hr, E_OUTOFMEMORY, "Failed to allocate memory for patch sequence information to package lookup.");
+
+        for (DWORD i = 0; i < pPackages->cPackages; ++i)
+        {
+            BURN_PACKAGE* pPackage = &pPackages->rgPackages[i];
+
+            if (BURN_PACKAGE_TYPE_MSP == pPackage->type)
+            {
+                pPackages->rgPatchInfo[pPackages->cPatchInfo].szPatchData = pPackage->Msp.sczApplicabilityXml;
+                pPackages->rgPatchInfo[pPackages->cPatchInfo].ePatchDataType = MSIPATCH_DATATYPE_XMLBLOB;
+                pPackages->rgPatchInfoToPackage[pPackages->cPatchInfo] = pPackage;
+                ++pPackages->cPatchInfo;
+
+                // Loop through all MSI packages seeing if any of them slipstream this MSP.
+                for (DWORD j = 0; j < pPackages->cPackages; ++j)
+                {
+                    BURN_PACKAGE* pMsiPackage = &pPackages->rgPackages[j];
+
+                    if (BURN_PACKAGE_TYPE_MSI == pMsiPackage->type)
+                    {
+                        for (DWORD k = 0; k < pMsiPackage->Msi.cSlipstreamMspPackages; ++k)
+                        {
+                            if (pMsiPackage->Msi.rgsczSlipstreamMspPackageIds[k] && CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, pPackage->sczId, -1, pMsiPackage->Msi.rgsczSlipstreamMspPackageIds[k], -1))
+                            {
+                                pMsiPackage->Msi.rgpSlipstreamMspPackages[k] = pPackage;
+
+                                ReleaseNullStr(pMsiPackage->Msi.rgsczSlipstreamMspPackageIds[k]); // we don't need the slipstream package id any longer so free it.
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    AssertSz(pPackages->cPatchInfo == cMspPackages, "Count of packages patch info should be equal to the number of MSP packages.");
+
+    hr = ParsePatchTargetCode(pPackages, pixnBundle);
+    ExitOnFailure(hr, "Failed to parse target product codes.");
+
+    hr = S_OK;
+
+LExit:
+    ReleaseObject(pixnNodes);
+    ReleaseObject(pixnNode);
+    ReleaseBSTR(bstrNodeName);
+    ReleaseStr(scz);
+
+    return hr;
+}
+
+extern "C" void PackageUninitialize(
+    __in BURN_PACKAGE* pPackage
+    )
+{
+    ReleaseStr(pPackage->sczId);
+    ReleaseStr(pPackage->sczLogPathVariable);
+    ReleaseStr(pPackage->sczRollbackLogPathVariable);
+    ReleaseStr(pPackage->sczInstallCondition);
+    ReleaseStr(pPackage->sczRollbackInstallCondition);
+    ReleaseStr(pPackage->sczCacheId);
+
+    if (pPackage->rgDependencyProviders)
+    {
+        for (DWORD i = 0; i < pPackage->cDependencyProviders; ++i)
+        {
+            DependencyUninitialize(pPackage->rgDependencyProviders + i);
+        }
+        MemFree(pPackage->rgDependencyProviders);
+    }
+
+    ReleaseMem(pPackage->rgPayloads);
+
+    switch (pPackage->type)
+    {
+    case BURN_PACKAGE_TYPE_EXE:
+        ExeEnginePackageUninitialize(pPackage); // TODO: Modularization
+        break;
+    case BURN_PACKAGE_TYPE_MSI:
+        MsiEnginePackageUninitialize(pPackage); // TODO: Modularization
+        break;
+    case BURN_PACKAGE_TYPE_MSP:
+        MspEnginePackageUninitialize(pPackage); // TODO: Modularization
+        break;
+    case BURN_PACKAGE_TYPE_MSU:
+        MsuEnginePackageUninitialize(pPackage); // TODO: Modularization
+        break;
+    }
+}
+
+extern "C" void PackagesUninitialize(
+    __in BURN_PACKAGES* pPackages
+    )
+{
+    if (pPackages->rgRollbackBoundaries)
+    {
+        for (DWORD i = 0; i < pPackages->cRollbackBoundaries; ++i)
+        {
+            ReleaseStr(pPackages->rgRollbackBoundaries[i].sczId);
+        }
+        MemFree(pPackages->rgRollbackBoundaries);
+    }
+
+    if (pPackages->rgPackages)
+    {
+        for (DWORD i = 0; i < pPackages->cPackages; ++i)
+        {
+            PackageUninitialize(pPackages->rgPackages + i);
+        }
+        MemFree(pPackages->rgPackages);
+    }
+
+    if (pPackages->rgCompatiblePackages)
+    {
+        for (DWORD i = 0; i < pPackages->cCompatiblePackages; ++i)
+        {
+            PackageUninitialize(pPackages->rgCompatiblePackages + i);
+        }
+        MemFree(pPackages->rgCompatiblePackages);
+    }
+
+    if (pPackages->rgPatchTargetCodes)
+    {
+        for (DWORD i = 0; i < pPackages->cPatchTargetCodes; ++i)
+        {
+            ReleaseStr(pPackages->rgPatchTargetCodes[i].sczTargetCode);
+        }
+        MemFree(pPackages->rgPatchTargetCodes);
+    }
+
+    ReleaseMem(pPackages->rgPatchInfo);
+    ReleaseMem(pPackages->rgPatchInfoToPackage);
+
+    // clear struct
+    memset(pPackages, 0, sizeof(BURN_PACKAGES));
+}
+
+extern "C" HRESULT PackageFindById(
+    __in BURN_PACKAGES* pPackages,
+    __in_z LPCWSTR wzId,
+    __out BURN_PACKAGE** ppPackage
+    )
+{
+    HRESULT hr = S_OK;
+    BURN_PACKAGE* pPackage = NULL;
+
+    for (DWORD i = 0; i < pPackages->cPackages; ++i)
+    {
+        pPackage = &pPackages->rgPackages[i];
+
+        if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, pPackage->sczId, -1, wzId, -1))
+        {
+            *ppPackage = pPackage;
+            ExitFunction1(hr = S_OK);
+        }
+    }
+
+    for (DWORD i = 0; i < pPackages->cCompatiblePackages; ++i)
+    {
+        pPackage = &pPackages->rgCompatiblePackages[i];
+
+        if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, pPackage->sczId, -1, wzId, -1))
+        {
+            *ppPackage = pPackage;
+            ExitFunction1(hr = S_OK);
+        }
+    }
+
+    hr = E_NOTFOUND;
+
+LExit:
+    return hr;
+}
+
+
+extern "C" HRESULT PackageFindRelatedById(
+    __in BURN_RELATED_BUNDLES* pRelatedBundles,
+    __in_z LPCWSTR wzId,
+    __out BURN_PACKAGE** ppPackage
+    )
+{
+    HRESULT hr = S_OK;
+    BURN_PACKAGE* pPackage = NULL;
+
+    for (DWORD i = 0; i < pRelatedBundles->cRelatedBundles; ++i)
+    {
+        pPackage = &pRelatedBundles->rgRelatedBundles[i].package;
+
+        if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, pPackage->sczId, -1, wzId, -1))
+        {
+            *ppPackage = pPackage;
+            ExitFunction1(hr = S_OK);
+        }
+    }
+
+    hr = E_NOTFOUND;
+
+LExit:
+    return hr;
+}
+
+/********************************************************************
+ PackageGetProperty - Determines if the property is defined
+  and optionally copies the property value.
+
+ Note: The caller must free psczValue if requested.
+
+ Note: Returns E_NOTFOUND if the property was not defined or if the
+  package does not support properties.
+
+*********************************************************************/
+extern "C" HRESULT PackageGetProperty(
+    __in const BURN_PACKAGE* pPackage,
+    __in_z LPCWSTR wzProperty,
+    __out_z_opt LPWSTR* psczValue
+    )
+{
+    HRESULT hr = E_NOTFOUND;
+    BURN_MSIPROPERTY* rgProperties = NULL;
+    DWORD cProperties = 0;
+
+    // For MSIs and MSPs, enumerate the properties looking for wzProperty.
+    if (BURN_PACKAGE_TYPE_MSI == pPackage->type)
+    {
+        rgProperties = pPackage->Msi.rgProperties;
+        cProperties = pPackage->Msi.cProperties;
+    }
+    else if (BURN_PACKAGE_TYPE_MSP == pPackage->type)
+    {
+        rgProperties = pPackage->Msp.rgProperties;
+        cProperties = pPackage->Msp.cProperties;
+    }
+
+    for (DWORD i = 0; i < cProperties; ++i)
+    {
+        const BURN_MSIPROPERTY* pProperty = &rgProperties[i];
+
+        if (CSTR_EQUAL == ::CompareStringW(LOCALE_NEUTRAL, 0, pProperty->sczId, -1, wzProperty, -1))
+        {
+            if (psczValue)
+            {
+                hr = StrAllocString(psczValue, pProperty->sczValue, 0);
+                ExitOnFailure(hr, "Failed to copy the property value.");
+            }
+
+            ExitFunction1(hr = S_OK);
+        }
+    }
+
+LExit:
+    return hr;
+}
+
+HRESULT PackageEnsureCompatiblePackagesArray(
+    __in BURN_PACKAGES* pPackages
+    )
+{
+    HRESULT hr = S_OK;
+
+    if (!pPackages->rgCompatiblePackages)
+    {
+        pPackages->rgCompatiblePackages = (BURN_PACKAGE*)MemAlloc(sizeof(BURN_PACKAGE) * pPackages->cPackages, TRUE);
+        ExitOnNull(pPackages->rgCompatiblePackages, hr, E_OUTOFMEMORY, "Failed to allocate memory for compatible packages.");
+    }
+
+LExit:
+    return hr;
+}
+
+
+// internal function declarations
+
+static HRESULT ParsePayloadRefsFromXml(
+    __in BURN_PACKAGE* pPackage,
+    __in BURN_PAYLOADS* pPayloads,
+    __in IXMLDOMNode* pixnPackage
+    )
+{
+    HRESULT hr = S_OK;
+    IXMLDOMNodeList* pixnNodes = NULL;
+    IXMLDOMNode* pixnNode = NULL;
+    DWORD cNodes = 0;
+    LPWSTR sczId = NULL;
+
+    // select package nodes
+    hr = XmlSelectNodes(pixnPackage, L"PayloadRef", &pixnNodes);
+    ExitOnFailure(hr, "Failed to select package nodes.");
+
+    // get package node count
+    hr = pixnNodes->get_length((long*)&cNodes);
+    ExitOnFailure(hr, "Failed to get package node count.");
+
+    if (!cNodes)
+    {
+        ExitFunction1(hr = S_OK);
+    }
+
+    // allocate memory for payload pointers
+    pPackage->rgPayloads = (BURN_PACKAGE_PAYLOAD*)MemAlloc(sizeof(BURN_PACKAGE_PAYLOAD) * cNodes, TRUE);
+    ExitOnNull(pPackage->rgPayloads, hr, E_OUTOFMEMORY, "Failed to allocate memory for package payloads.");
+
+    pPackage->cPayloads = cNodes;
+
+    // parse package elements
+    for (DWORD i = 0; i < cNodes; ++i)
+    {
+        BURN_PACKAGE_PAYLOAD* pPackagePayload = &pPackage->rgPayloads[i];
+
+        hr = XmlNextElement(pixnNodes, &pixnNode, NULL);
+        ExitOnFailure(hr, "Failed to get next node.");
+
+        // @Id
+        hr = XmlGetAttributeEx(pixnNode, L"Id", &sczId);
+        ExitOnFailure(hr, "Failed to get Id attribute.");
+
+        // find payload
+        hr = PayloadFindById(pPayloads, sczId, &pPackagePayload->pPayload);
+        ExitOnFailure(hr, "Failed to find payload.");
+
+        // prepare next iteration
+        ReleaseNullObject(pixnNode);
+    }
+
+    hr = S_OK;
+
+LExit:
+    ReleaseObject(pixnNodes);
+    ReleaseObject(pixnNode);
+    ReleaseStr(sczId);
+
+    return hr;
+}
+
+static HRESULT ParsePatchTargetCode(
+    __in BURN_PACKAGES* pPackages,
+    __in IXMLDOMNode* pixnBundle
+    )
+{
+    HRESULT hr = S_OK;
+    IXMLDOMNodeList* pixnNodes = NULL;
+    IXMLDOMNode* pixnNode = NULL;
+    DWORD cNodes = 0;
+    BSTR bstrNodeText = NULL;
+    BOOL fProduct;
+
+    hr = XmlSelectNodes(pixnBundle, L"PatchTargetCode", &pixnNodes);
+    ExitOnFailure(hr, "Failed to select PatchTargetCode nodes.");
+
+    hr = pixnNodes->get_length((long*)&cNodes);
+    ExitOnFailure(hr, "Failed to get PatchTargetCode node count.");
+
+    if (!cNodes)
+    {
+        ExitFunction1(hr = S_OK);
+    }
+
+    pPackages->rgPatchTargetCodes = (BURN_PATCH_TARGETCODE*)MemAlloc(sizeof(BURN_PATCH_TARGETCODE) * cNodes, TRUE);
+    ExitOnNull(pPackages->rgPatchTargetCodes, hr, E_OUTOFMEMORY, "Failed to allocate memory for patch targetcodes.");
+
+    pPackages->cPatchTargetCodes = cNodes;
+
+    for (DWORD i = 0; i < cNodes; ++i)
+    {
+        BURN_PATCH_TARGETCODE* pTargetCode = pPackages->rgPatchTargetCodes + i;
+
+        hr = XmlNextElement(pixnNodes, &pixnNode, NULL);
+        ExitOnFailure(hr, "Failed to get next node.");
+
+        hr = XmlGetAttributeEx(pixnNode, L"TargetCode", &pTargetCode->sczTargetCode);
+        ExitOnFailure(hr, "Failed to get @TargetCode attribute.");
+
+        hr = XmlGetYesNoAttribute(pixnNode, L"Product", &fProduct);
+        if (E_NOTFOUND == hr)
+        {
+            fProduct = FALSE;
+            hr = S_OK;
+        }
+        ExitOnFailure(hr, "Failed to get @Product.");
+
+        pTargetCode->type = fProduct ? BURN_PATCH_TARGETCODE_TYPE_PRODUCT : BURN_PATCH_TARGETCODE_TYPE_UPGRADE;
+
+        // prepare next iteration
+        ReleaseNullBSTR(bstrNodeText);
+        ReleaseNullObject(pixnNode);
+    }
+
+LExit:
+    ReleaseBSTR(bstrNodeText);
+    ReleaseObject(pixnNode);
+    ReleaseObject(pixnNodes);
+
+    return hr;
+}
+
+static HRESULT FindRollbackBoundaryById(
+    __in BURN_PACKAGES* pPackages,
+    __in_z LPCWSTR wzId,
+    __out BURN_ROLLBACK_BOUNDARY** ppRollbackBoundary
+    )
+{
+    HRESULT hr = S_OK;
+    BURN_ROLLBACK_BOUNDARY* pRollbackBoundary = NULL;
+
+    for (DWORD i = 0; i < pPackages->cRollbackBoundaries; ++i)
+    {
+        pRollbackBoundary = &pPackages->rgRollbackBoundaries[i];
+
+        if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, pRollbackBoundary->sczId, -1, wzId, -1))
+        {
+            *ppRollbackBoundary = pRollbackBoundary;
+            ExitFunction1(hr = S_OK);
+        }
+    }
+
+    hr = E_NOTFOUND;
+
+LExit:
+    return hr;
+}
diff --git a/src/engine/package.h b/src/engine/package.h
new file mode 100644
index 00000000..c295378e
--- /dev/null
+++ b/src/engine/package.h
@@ -0,0 +1,336 @@
+#pragma once
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+struct _BURN_RELATED_BUNDLES;
+typedef _BURN_RELATED_BUNDLES BURN_RELATED_BUNDLES;
+
+struct _BURN_PACKAGE;
+typedef _BURN_PACKAGE BURN_PACKAGE;
+
+// constants
+
+enum BURN_EXE_EXIT_CODE_TYPE
+{
+    BURN_EXE_EXIT_CODE_TYPE_NONE,
+    BURN_EXE_EXIT_CODE_TYPE_SUCCESS,
+    BURN_EXE_EXIT_CODE_TYPE_ERROR,
+    BURN_EXE_EXIT_CODE_TYPE_SCHEDULE_REBOOT,
+    BURN_EXE_EXIT_CODE_TYPE_FORCE_REBOOT,
+};
+
+enum BURN_EXE_PROTOCOL_TYPE
+{
+    BURN_EXE_PROTOCOL_TYPE_NONE,
+    BURN_EXE_PROTOCOL_TYPE_BURN,
+    BURN_EXE_PROTOCOL_TYPE_NETFX4,
+};
+
+enum BURN_PACKAGE_TYPE
+{
+    BURN_PACKAGE_TYPE_NONE,
+    BURN_PACKAGE_TYPE_EXE,
+    BURN_PACKAGE_TYPE_MSI,
+    BURN_PACKAGE_TYPE_MSP,
+    BURN_PACKAGE_TYPE_MSU,
+};
+
+enum BURN_CACHE_STATE
+{
+    BURN_CACHE_STATE_NONE,
+    BURN_CACHE_STATE_PARTIAL,
+    BURN_CACHE_STATE_COMPLETE,
+};
+
+enum BURN_CACHE_TYPE
+{
+    BURN_CACHE_TYPE_NO,
+    BURN_CACHE_TYPE_YES,
+    BURN_CACHE_TYPE_ALWAYS,
+};
+
+enum BURN_DEPENDENCY_ACTION
+{
+    BURN_DEPENDENCY_ACTION_NONE,
+    BURN_DEPENDENCY_ACTION_REGISTER,
+    BURN_DEPENDENCY_ACTION_UNREGISTER,
+};
+
+enum BURN_PATCH_TARGETCODE_TYPE
+{
+    BURN_PATCH_TARGETCODE_TYPE_UNKNOWN,
+    BURN_PATCH_TARGETCODE_TYPE_PRODUCT,
+    BURN_PATCH_TARGETCODE_TYPE_UPGRADE,
+};
+
+// structs
+
+typedef struct _BURN_EXE_EXIT_CODE
+{
+    BURN_EXE_EXIT_CODE_TYPE type;
+    DWORD dwCode;
+    BOOL fWildcard;
+} BURN_EXE_EXIT_CODE;
+
+typedef struct _BURN_EXE_COMMAND_LINE_ARGUMENT
+{
+    LPWSTR sczInstallArgument;
+    LPWSTR sczUninstallArgument;
+    LPWSTR sczRepairArgument;
+    LPWSTR sczCondition;
+} BURN_EXE_COMMAND_LINE_ARGUMENT;
+
+typedef struct _BURN_MSPTARGETPRODUCT
+{
+    MSIINSTALLCONTEXT context;
+    DWORD dwOrder;
+    WCHAR wzTargetProductCode[39];
+    BURN_PACKAGE* pChainedTargetPackage;
+    BOOL fSlipstream;
+
+    BOOTSTRAPPER_PACKAGE_STATE patchPackageState; // only valid after Detect.
+    BOOTSTRAPPER_ACTION_STATE execute;            // only valid during Plan.
+    BOOTSTRAPPER_ACTION_STATE rollback;           // only valid during Plan.
+} BURN_MSPTARGETPRODUCT;
+
+typedef struct _BURN_MSIPROPERTY
+{
+    LPWSTR sczId;
+    LPWSTR sczValue; // used during forward execution
+    LPWSTR sczRollbackValue;  // used during rollback
+    LPWSTR sczCondition;
+} BURN_MSIPROPERTY;
+
+typedef struct _BURN_MSIFEATURE
+{
+    LPWSTR sczId;
+    LPWSTR sczAddLocalCondition;
+    LPWSTR sczAddSourceCondition;
+    LPWSTR sczAdvertiseCondition;
+    LPWSTR sczRollbackAddLocalCondition;
+    LPWSTR sczRollbackAddSourceCondition;
+    LPWSTR sczRollbackAdvertiseCondition;
+
+    BOOTSTRAPPER_FEATURE_STATE currentState;   // only valid after Detect.
+    BOOTSTRAPPER_FEATURE_ACTION execute;       // only valid during Plan.
+    BOOTSTRAPPER_FEATURE_ACTION rollback;      // only valid during Plan.
+} BURN_MSIFEATURE;
+
+typedef struct _BURN_RELATED_MSI
+{
+    LPWSTR sczUpgradeCode;
+    DWORD64 qwMinVersion;
+    DWORD64 qwMaxVersion;
+    BOOL fMinProvided;
+    BOOL fMaxProvided;
+    BOOL fMinInclusive;
+    BOOL fMaxInclusive;
+    BOOL fOnlyDetect;
+    BOOL fLangInclusive;
+
+    DWORD* rgdwLanguages;
+    DWORD cLanguages;
+} BURN_RELATED_MSI;
+
+typedef struct _BURN_PACKAGE_PAYLOAD
+{
+    BURN_PAYLOAD* pPayload;
+    BOOL fCached;
+} BURN_PACKAGE_PAYLOAD;
+
+typedef struct _BURN_DEPENDENCY_PROVIDER
+{
+    LPWSTR sczKey;
+    LPWSTR sczVersion;
+    LPWSTR sczDisplayName;
+    BOOL fImported;
+} BURN_DEPENDENCY_PROVIDER;
+
+typedef struct _BURN_ROLLBACK_BOUNDARY
+{
+    LPWSTR sczId;
+    BOOL fVital;
+    BOOL fTransaction;
+} BURN_ROLLBACK_BOUNDARY;
+
+typedef struct _BURN_PATCH_TARGETCODE
+{
+    LPWSTR sczTargetCode;
+    BURN_PATCH_TARGETCODE_TYPE type;
+} BURN_PATCH_TARGETCODE;
+
+typedef struct _BURN_PACKAGE
+{
+    LPWSTR sczId;
+
+    LPWSTR sczLogPathVariable;          // name of the variable that will be set to the log path.
+    LPWSTR sczRollbackLogPathVariable;  // name of the variable that will be set to the rollback path.
+
+    LPWSTR sczInstallCondition;
+    LPWSTR sczRollbackInstallCondition;
+    BOOL fPerMachine;
+    BOOL fUninstallable;
+    BOOL fVital;
+
+    BURN_CACHE_TYPE cacheType;
+    LPWSTR sczCacheId;
+
+    DWORD64 qwInstallSize;
+    DWORD64 qwSize;
+
+    BURN_ROLLBACK_BOUNDARY* pRollbackBoundaryForward;  // used during install and repair.
+    BURN_ROLLBACK_BOUNDARY* pRollbackBoundaryBackward; // used during uninstall.
+
+    BOOTSTRAPPER_PACKAGE_STATE currentState;    // only valid after Detect.
+    BURN_CACHE_STATE cache;                     // only valid after Detect.
+    BOOTSTRAPPER_PACKAGE_STATE expected;        // only valid during Plan.
+    BOOTSTRAPPER_REQUEST_STATE defaultRequested;// only valid during Plan.
+    BOOTSTRAPPER_REQUEST_STATE requested;       // only valid during Plan.
+    BOOL fAcquire;                              // only valid during Plan.
+    BOOL fUncache;                              // only valid during Plan.
+    BOOTSTRAPPER_ACTION_STATE execute;          // only valid during Plan.
+    BOOTSTRAPPER_ACTION_STATE rollback;         // only valid during Plan.
+    BURN_DEPENDENCY_ACTION providerExecute;     // only valid during Plan.
+    BURN_DEPENDENCY_ACTION providerRollback;    // only valid during Plan.
+    BURN_DEPENDENCY_ACTION dependencyExecute;   // only valid during Plan.
+    BURN_DEPENDENCY_ACTION dependencyRollback;  // only valid during Plan.
+    BOOL fDependencyManagerWasHere;             // only valid during Plan.
+    HRESULT hrCacheResult;                      // only valid during Apply.
+
+    BURN_PACKAGE_PAYLOAD* rgPayloads;
+    DWORD cPayloads;
+
+    BURN_DEPENDENCY_PROVIDER* rgDependencyProviders;
+    DWORD cDependencyProviders;
+
+    BURN_PACKAGE_TYPE type;
+    union
+    {
+        struct
+        {
+            LPWSTR sczDetectCondition;
+            LPWSTR sczInstallArguments;
+            LPWSTR sczRepairArguments;
+            LPWSTR sczUninstallArguments;
+            LPWSTR sczIgnoreDependencies;
+            LPWSTR sczAncestors;
+
+            BOOL fPseudoBundle;
+
+            BOOL fRepairable;
+            BURN_EXE_PROTOCOL_TYPE protocol;
+
+            BOOL fSupportsAncestors;
+
+            BURN_EXE_EXIT_CODE* rgExitCodes;
+            DWORD cExitCodes;
+
+            BURN_EXE_COMMAND_LINE_ARGUMENT* rgCommandLineArguments;
+            DWORD cCommandLineArguments;
+        } Exe;
+        struct
+        {
+            LPWSTR sczProductCode;
+            DWORD dwLanguage;
+            DWORD64 qwVersion;
+            LPWSTR sczInstalledProductCode;
+            DWORD64 qwInstalledVersion;
+            BOOL fDisplayInternalUI;
+            LPWSTR sczUpgradeCode;
+
+            BURN_MSIPROPERTY* rgProperties;
+            DWORD cProperties;
+
+            BURN_MSIFEATURE* rgFeatures;
+            DWORD cFeatures;
+
+            BURN_RELATED_MSI* rgRelatedMsis;
+            DWORD cRelatedMsis;
+
+            _BURN_PACKAGE** rgpSlipstreamMspPackages;
+            LPWSTR* rgsczSlipstreamMspPackageIds;
+            DWORD cSlipstreamMspPackages;
+
+            BOOL fCompatibleInstalled;
+        } Msi;
+        struct
+        {
+            LPWSTR sczPatchCode;
+            LPWSTR sczApplicabilityXml;
+            BOOL fDisplayInternalUI;
+
+            BURN_MSIPROPERTY* rgProperties;
+            DWORD cProperties;
+
+            BURN_MSPTARGETPRODUCT* rgTargetProducts;
+            DWORD cTargetProductCodes;
+        } Msp;
+        struct
+        {
+            LPWSTR sczDetectCondition;
+            LPWSTR sczKB;
+        } Msu;
+    };
+} BURN_PACKAGE;
+
+typedef struct _BURN_PACKAGES
+{
+    BURN_ROLLBACK_BOUNDARY* rgRollbackBoundaries;
+    DWORD cRollbackBoundaries;
+
+    BURN_PACKAGE* rgPackages;
+    DWORD cPackages;
+
+    BURN_PACKAGE* rgCompatiblePackages;
+    DWORD cCompatiblePackages;
+
+    BURN_PATCH_TARGETCODE* rgPatchTargetCodes;
+    DWORD cPatchTargetCodes;
+
+    MSIPATCHSEQUENCEINFOW* rgPatchInfo;
+    BURN_PACKAGE** rgPatchInfoToPackage; // direct lookup from patch information to the (MSP) package it describes.
+                                         // Thus this array is the exact same size as rgPatchInfo.
+    DWORD cPatchInfo;
+} BURN_PACKAGES;
+
+
+// function declarations
+
+HRESULT PackagesParseFromXml(
+    __in BURN_PACKAGES* pPackages,
+    __in BURN_PAYLOADS* pPayloads,
+    __in IXMLDOMNode* pixnBundle
+    );
+void PackageUninitialize(
+    __in BURN_PACKAGE* pPackage
+    );
+void PackagesUninitialize(
+    __in BURN_PACKAGES* pPackages
+    );
+HRESULT PackageFindById(
+    __in BURN_PACKAGES* pPackages,
+    __in_z LPCWSTR wzId,
+    __out BURN_PACKAGE** ppPackage
+    );
+HRESULT PackageFindRelatedById(
+    __in BURN_RELATED_BUNDLES* pRelatedBundles,
+    __in_z LPCWSTR wzId,
+    __out BURN_PACKAGE** ppPackage
+    );
+HRESULT PackageGetProperty(
+    __in const BURN_PACKAGE* pPackage,
+    __in_z LPCWSTR wzProperty,
+    __out_z_opt LPWSTR* psczValue
+    );
+HRESULT PackageEnsureCompatiblePackagesArray(
+    __in BURN_PACKAGES* pPackages
+    );
+
+
+#if defined(__cplusplus)
+}
+#endif
diff --git a/src/engine/payload.cpp b/src/engine/payload.cpp
new file mode 100644
index 00000000..6833288f
--- /dev/null
+++ b/src/engine/payload.cpp
@@ -0,0 +1,367 @@
+// 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.
+
+#include "precomp.h"
+
+
+// internal function declarations
+
+static HRESULT FindEmbeddedBySourcePath(
+    __in BURN_PAYLOADS* pPayloads,
+    __in_opt BURN_CONTAINER* pContainer,
+    __in_z LPCWSTR wzStreamName,
+    __out BURN_PAYLOAD** ppPayload
+    );
+
+
+// function definitions
+
+extern "C" HRESULT PayloadsParseFromXml(
+    __in BURN_PAYLOADS* pPayloads,
+    __in_opt BURN_CONTAINERS* pContainers,
+    __in_opt BURN_CATALOGS* pCatalogs,
+    __in IXMLDOMNode* pixnBundle
+    )
+{
+    HRESULT hr = S_OK;
+    IXMLDOMNodeList* pixnNodes = NULL;
+    IXMLDOMNode* pixnNode = NULL;
+    DWORD cNodes = 0;
+    LPWSTR scz = NULL;
+
+    // select payload nodes
+    hr = XmlSelectNodes(pixnBundle, L"Payload", &pixnNodes);
+    ExitOnFailure(hr, "Failed to select payload nodes.");
+
+    // get payload node count
+    hr = pixnNodes->get_length((long*)&cNodes);
+    ExitOnFailure(hr, "Failed to get payload node count.");
+
+    if (!cNodes)
+    {
+        ExitFunction();
+    }
+
+    // allocate memory for payloads
+    pPayloads->rgPayloads = (BURN_PAYLOAD*)MemAlloc(sizeof(BURN_PAYLOAD) * cNodes, TRUE);
+    ExitOnNull(pPayloads->rgPayloads, hr, E_OUTOFMEMORY, "Failed to allocate memory for payload structs.");
+
+    pPayloads->cPayloads = cNodes;
+
+    // parse search elements
+    for (DWORD i = 0; i < cNodes; ++i)
+    {
+        BURN_PAYLOAD* pPayload = &pPayloads->rgPayloads[i];
+
+        hr = XmlNextElement(pixnNodes, &pixnNode, NULL);
+        ExitOnFailure(hr, "Failed to get next node.");
+
+        // @Id
+        hr = XmlGetAttributeEx(pixnNode, L"Id", &pPayload->sczKey);
+        ExitOnFailure(hr, "Failed to get @Id.");
+
+        // @FilePath
+        hr = XmlGetAttributeEx(pixnNode, L"FilePath", &pPayload->sczFilePath);
+        ExitOnFailure(hr, "Failed to get @FilePath.");
+
+        // @Packaging
+        hr = XmlGetAttributeEx(pixnNode, L"Packaging", &scz);
+        ExitOnFailure(hr, "Failed to get @Packaging.");
+
+        if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, scz, -1, L"download", -1))
+        {
+            pPayload->packaging = BURN_PAYLOAD_PACKAGING_DOWNLOAD;
+        }
+        else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, scz, -1, L"embedded", -1))
+        {
+            pPayload->packaging = BURN_PAYLOAD_PACKAGING_EMBEDDED;
+        }
+        else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, scz, -1, L"external", -1))
+        {
+            pPayload->packaging = BURN_PAYLOAD_PACKAGING_EXTERNAL;
+        }
+        else
+        {
+            hr = E_INVALIDARG;
+            ExitOnFailure(hr, "Invalid value for @Packaging: %ls", scz);
+        }
+
+        // @Container
+        if (pContainers)
+        {
+            hr = XmlGetAttributeEx(pixnNode, L"Container", &scz);
+            if (E_NOTFOUND != hr || BURN_PAYLOAD_PACKAGING_EMBEDDED == pPayload->packaging)
+            {
+                ExitOnFailure(hr, "Failed to get @Container.");
+
+                // find container
+                hr = ContainerFindById(pContainers, scz, &pPayload->pContainer);
+                ExitOnFailure(hr, "Failed to to find container: %ls", scz);
+            }
+        }
+
+        // @LayoutOnly
+        hr = XmlGetYesNoAttribute(pixnNode, L"LayoutOnly", &pPayload->fLayoutOnly);
+        if (E_NOTFOUND != hr)
+        {
+            ExitOnFailure(hr, "Failed to get @LayoutOnly.");
+        }
+
+        // @SourcePath
+        hr = XmlGetAttributeEx(pixnNode, L"SourcePath", &pPayload->sczSourcePath);
+        if (E_NOTFOUND != hr || BURN_PAYLOAD_PACKAGING_DOWNLOAD != pPayload->packaging)
+        {
+            ExitOnFailure(hr, "Failed to get @SourcePath.");
+        }
+
+        // @DownloadUrl
+        hr = XmlGetAttributeEx(pixnNode, L"DownloadUrl", &pPayload->downloadSource.sczUrl);
+        if (E_NOTFOUND != hr || BURN_PAYLOAD_PACKAGING_DOWNLOAD == pPayload->packaging)
+        {
+            ExitOnFailure(hr, "Failed to get @DownloadUrl.");
+        }
+
+        // @FileSize
+        hr = XmlGetAttributeEx(pixnNode, L"FileSize", &scz);
+        if (E_NOTFOUND != hr)
+        {
+            ExitOnFailure(hr, "Failed to get @FileSize.");
+
+            hr = StrStringToUInt64(scz, 0, &pPayload->qwFileSize);
+            ExitOnFailure(hr, "Failed to parse @FileSize.");
+        }
+
+        // @CertificateAuthorityKeyIdentifier
+        hr = XmlGetAttributeEx(pixnNode, L"CertificateRootPublicKeyIdentifier", &scz);
+        if (E_NOTFOUND != hr)
+        {
+            ExitOnFailure(hr, "Failed to get @CertificateRootPublicKeyIdentifier.");
+
+            hr = StrAllocHexDecode(scz, &pPayload->pbCertificateRootPublicKeyIdentifier, &pPayload->cbCertificateRootPublicKeyIdentifier);
+            ExitOnFailure(hr, "Failed to hex decode @CertificateRootPublicKeyIdentifier.");
+        }
+
+        // @CertificateThumbprint
+        hr = XmlGetAttributeEx(pixnNode, L"CertificateRootThumbprint", &scz);
+        if (E_NOTFOUND != hr)
+        {
+            ExitOnFailure(hr, "Failed to get @CertificateRootThumbprint.");
+
+            hr = StrAllocHexDecode(scz, &pPayload->pbCertificateRootThumbprint, &pPayload->cbCertificateRootThumbprint);
+            ExitOnFailure(hr, "Failed to hex decode @CertificateRootThumbprint.");
+        }
+
+        // @Hash
+        hr = XmlGetAttributeEx(pixnNode, L"Hash", &scz);
+        ExitOnFailure(hr, "Failed to get @Hash.");
+
+        hr = StrAllocHexDecode(scz, &pPayload->pbHash, &pPayload->cbHash);
+        ExitOnFailure(hr, "Failed to hex decode the Payload/@Hash.");
+
+        // @Catalog
+        hr = XmlGetAttributeEx(pixnNode, L"Catalog", &scz);
+        if (E_NOTFOUND != hr)
+        {
+            ExitOnFailure(hr, "Failed to get @Catalog.");
+
+            hr = CatalogFindById(pCatalogs, scz, &pPayload->pCatalog);
+            ExitOnFailure(hr, "Failed to find catalog.");
+        }
+
+        // prepare next iteration
+        ReleaseNullObject(pixnNode);
+    }
+
+    hr = S_OK;
+
+LExit:
+    ReleaseObject(pixnNodes);
+    ReleaseObject(pixnNode);
+    ReleaseStr(scz);
+
+    return hr;
+}
+
+extern "C" void PayloadsUninitialize(
+    __in BURN_PAYLOADS* pPayloads
+    )
+{
+    if (pPayloads->rgPayloads)
+    {
+        for (DWORD i = 0; i < pPayloads->cPayloads; ++i)
+        {
+            BURN_PAYLOAD* pPayload = &pPayloads->rgPayloads[i];
+
+            ReleaseStr(pPayload->sczKey);
+            ReleaseStr(pPayload->sczFilePath);
+            ReleaseMem(pPayload->pbHash);
+            ReleaseMem(pPayload->pbCertificateRootThumbprint);
+            ReleaseMem(pPayload->pbCertificateRootPublicKeyIdentifier);
+            ReleaseStr(pPayload->sczSourcePath);
+            ReleaseStr(pPayload->sczLocalFilePath);
+            ReleaseStr(pPayload->downloadSource.sczUrl);
+            ReleaseStr(pPayload->downloadSource.sczUser);
+            ReleaseStr(pPayload->downloadSource.sczPassword);
+        }
+        MemFree(pPayloads->rgPayloads);
+    }
+
+    // clear struct
+    memset(pPayloads, 0, sizeof(BURN_PAYLOADS));
+}
+
+extern "C" HRESULT PayloadExtractFromContainer(
+    __in BURN_PAYLOADS* pPayloads,
+    __in_opt BURN_CONTAINER* pContainer,
+    __in BURN_CONTAINER_CONTEXT* pContainerContext,
+    __in_z LPCWSTR wzTargetDir
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR sczStreamName = NULL;
+    LPWSTR sczDirectory = NULL;
+    BURN_PAYLOAD* pPayload = NULL;
+
+    // extract all payloads
+    for (;;)
+    {
+        // get next stream
+        hr = ContainerNextStream(pContainerContext, &sczStreamName);
+        if (E_NOMOREITEMS == hr)
+        {
+            hr = S_OK;
+            break;
+        }
+        ExitOnFailure(hr, "Failed to get next stream.");
+
+        // find payload by stream name
+        hr = FindEmbeddedBySourcePath(pPayloads, pContainer, sczStreamName, &pPayload);
+        ExitOnFailure(hr, "Failed to find embedded payload: %ls", sczStreamName);
+
+        // make file path
+        hr = PathConcat(wzTargetDir, pPayload->sczFilePath, &pPayload->sczLocalFilePath);
+        ExitOnFailure(hr, "Failed to concat file paths.");
+
+        // extract file
+        hr = PathGetDirectory(pPayload->sczLocalFilePath, &sczDirectory);
+        ExitOnFailure(hr, "Failed to get directory portion of local file path");
+
+        hr = DirEnsureExists(sczDirectory, NULL);
+        ExitOnFailure(hr, "Failed to ensure directory exists");
+
+        hr = ContainerStreamToFile(pContainerContext, pPayload->sczLocalFilePath);
+        ExitOnFailure(hr, "Failed to extract file.");
+
+        // flag that the payload has been acquired
+        pPayload->state = BURN_PAYLOAD_STATE_ACQUIRED;
+    }
+
+    // locate any payloads that were not extracted
+    for (DWORD i = 0; i < pPayloads->cPayloads; ++i)
+    {
+        pPayload = &pPayloads->rgPayloads[i];
+
+        // if the payload is part of the container
+        if (!pContainer || pPayload->pContainer == pContainer)
+        {
+            // if the payload has not been acquired
+            if (BURN_PAYLOAD_STATE_ACQUIRED > pPayload->state)
+            {
+                hr = E_INVALIDDATA;
+                ExitOnRootFailure(hr, "Payload was not found in container: %ls", pPayload->sczKey);
+            }
+        }
+    }
+
+LExit:
+    ReleaseStr(sczStreamName);
+    ReleaseStr(sczDirectory);
+
+    return hr;
+}
+
+extern "C" HRESULT PayloadFindById(
+    __in BURN_PAYLOADS* pPayloads,
+    __in_z LPCWSTR wzId,
+    __out BURN_PAYLOAD** ppPayload
+    )
+{
+    HRESULT hr = S_OK;
+    BURN_PAYLOAD* pPayload = NULL;
+
+    for (DWORD i = 0; i < pPayloads->cPayloads; ++i)
+    {
+        pPayload = &pPayloads->rgPayloads[i];
+
+        if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, pPayload->sczKey, -1, wzId, -1))
+        {
+            *ppPayload = pPayload;
+            ExitFunction1(hr = S_OK);
+        }
+    }
+
+    hr = E_NOTFOUND;
+
+LExit:
+    return hr;
+}
+
+extern "C" HRESULT PayloadFindEmbeddedBySourcePath(
+    __in BURN_PAYLOADS* pPayloads,
+    __in_z LPCWSTR wzStreamName,
+    __out BURN_PAYLOAD** ppPayload
+    )
+{
+    HRESULT hr = S_OK;
+    BURN_PAYLOAD* pPayload = NULL;
+
+    for (DWORD i = 0; i < pPayloads->cPayloads; ++i)
+    {
+        pPayload = &pPayloads->rgPayloads[i];
+
+        if (BURN_PAYLOAD_PACKAGING_EMBEDDED == pPayload->packaging)
+        {
+            if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, pPayload->sczSourcePath, -1, wzStreamName, -1))
+            {
+                *ppPayload = pPayload;
+                ExitFunction1(hr = S_OK);
+            }
+        }
+    }
+
+    hr = E_NOTFOUND;
+
+LExit:
+    return hr;
+}
+
+
+// internal function definitions
+
+static HRESULT FindEmbeddedBySourcePath(
+    __in BURN_PAYLOADS* pPayloads,
+    __in_opt BURN_CONTAINER* pContainer,
+    __in_z LPCWSTR wzStreamName,
+    __out BURN_PAYLOAD** ppPayload
+    )
+{
+    HRESULT hr = S_OK;
+
+    for (DWORD i = 0; i < pPayloads->cPayloads; ++i)
+    {
+        BURN_PAYLOAD* pPayload = &pPayloads->rgPayloads[i];
+
+        if (BURN_PAYLOAD_PACKAGING_EMBEDDED == pPayload->packaging && (!pContainer || pPayload->pContainer == pContainer))
+        {
+            if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, pPayload->sczSourcePath, -1, wzStreamName, -1))
+            {
+                *ppPayload = pPayload;
+                ExitFunction1(hr = S_OK);
+            }
+        }
+    }
+
+    hr = E_NOTFOUND;
+
+LExit:
+    return hr;
+}
diff --git a/src/engine/payload.h b/src/engine/payload.h
new file mode 100644
index 00000000..0c7b68e4
--- /dev/null
+++ b/src/engine/payload.h
@@ -0,0 +1,93 @@
+#pragma once
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+
+// constants
+
+enum BURN_PAYLOAD_PACKAGING
+{
+    BURN_PAYLOAD_PACKAGING_NONE,
+    BURN_PAYLOAD_PACKAGING_DOWNLOAD,
+    BURN_PAYLOAD_PACKAGING_EMBEDDED,
+    BURN_PAYLOAD_PACKAGING_EXTERNAL,
+};
+
+enum BURN_PAYLOAD_STATE
+{
+    BURN_PAYLOAD_STATE_NONE,
+    BURN_PAYLOAD_STATE_ACQUIRED,
+    BURN_PAYLOAD_STATE_CACHED,
+};
+
+
+// structs
+
+typedef struct _BURN_PAYLOAD
+{
+    LPWSTR sczKey;
+    BURN_PAYLOAD_PACKAGING packaging;
+    BOOL fLayoutOnly;
+    DWORD64 qwFileSize;
+    LPWSTR sczFilePath; // file path relative to the execute location
+
+    BURN_CATALOG *pCatalog; // used to verify this payload
+    BYTE* pbCertificateRootPublicKeyIdentifier;
+    DWORD cbCertificateRootPublicKeyIdentifier;
+    BYTE* pbCertificateRootThumbprint;
+    DWORD cbCertificateRootThumbprint;
+    BYTE* pbHash;
+    DWORD cbHash;
+
+    LPWSTR sczSourcePath;
+    BURN_CONTAINER* pContainer;
+    DOWNLOAD_SOURCE downloadSource;
+
+    // mutable members
+    BURN_PAYLOAD_STATE state;
+    LPWSTR sczLocalFilePath; // location of extracted or downloaded copy
+} BURN_PAYLOAD;
+
+typedef struct _BURN_PAYLOADS
+{
+    BURN_PAYLOAD* rgPayloads;
+    DWORD cPayloads;
+} BURN_PAYLOADS;
+
+
+// functions
+
+HRESULT PayloadsParseFromXml(
+    __in BURN_PAYLOADS* pPayloads,
+    __in_opt BURN_CONTAINERS* pContainers,
+    __in_opt BURN_CATALOGS* pCatalogs,
+    __in IXMLDOMNode* pixnBundle
+    );
+void PayloadsUninitialize(
+    __in BURN_PAYLOADS* pPayloads
+    );
+HRESULT PayloadExtractFromContainer(
+    __in BURN_PAYLOADS* pPayloads,
+    __in_opt BURN_CONTAINER* pContainer,
+    __in BURN_CONTAINER_CONTEXT* pContainerContext,
+    __in_z LPCWSTR wzTargetDir
+    );
+HRESULT PayloadFindById(
+    __in BURN_PAYLOADS* pPayloads,
+    __in_z LPCWSTR wzId,
+    __out BURN_PAYLOAD** ppPayload
+    );
+HRESULT PayloadFindEmbeddedBySourcePath(
+    __in BURN_PAYLOADS* pPayloads,
+    __in_z LPCWSTR wzStreamName,
+    __out BURN_PAYLOAD** ppPayload
+    );
+
+
+#if defined(__cplusplus)
+}
+#endif
diff --git a/src/engine/pipe.cpp b/src/engine/pipe.cpp
new file mode 100644
index 00000000..7ecc4859
--- /dev/null
+++ b/src/engine/pipe.cpp
@@ -0,0 +1,873 @@
+// 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.
+
+#include "precomp.h"
+
+static const DWORD PIPE_64KB = 64 * 1024;
+static const DWORD PIPE_WAIT_FOR_CONNECTION = 100;   // wait a 10th of a second,
+static const DWORD PIPE_RETRY_FOR_CONNECTION = 1800; // for up to 3 minutes.
+
+static const LPCWSTR PIPE_NAME_FORMAT_STRING = L"\\\\.\\pipe\\%ls";
+static const LPCWSTR CACHE_PIPE_NAME_FORMAT_STRING = L"\\\\.\\pipe\\%ls.Cache";
+
+static HRESULT AllocatePipeMessage(
+    __in DWORD dwMessage,
+    __in_bcount_opt(cbData) LPVOID pvData,
+    __in DWORD cbData,
+    __out_bcount(cb) LPVOID* ppvMessage,
+    __out DWORD* cbMessage
+    );
+static void FreePipeMessage(
+    __in BURN_PIPE_MESSAGE *pMsg
+    );
+static HRESULT WritePipeMessage(
+    __in HANDLE hPipe,
+    __in DWORD dwMessage,
+    __in_bcount_opt(cbData) LPVOID pvData,
+    __in DWORD cbData
+    );
+static HRESULT GetPipeMessage(
+    __in HANDLE hPipe,
+    __in BURN_PIPE_MESSAGE* pMsg
+    );
+static HRESULT ChildPipeConnected(
+    __in HANDLE hPipe,
+    __in_z LPCWSTR wzSecret,
+    __inout DWORD* pdwProcessId
+    );
+
+
+
+/*******************************************************************
+ PipeConnectionInitialize - initialize pipe connection data.
+
+*******************************************************************/
+void PipeConnectionInitialize(
+    __in BURN_PIPE_CONNECTION* pConnection
+    )
+{
+    memset(pConnection, 0, sizeof(BURN_PIPE_CONNECTION));
+    pConnection->hPipe = INVALID_HANDLE_VALUE;
+    pConnection->hCachePipe = INVALID_HANDLE_VALUE;
+}
+
+/*******************************************************************
+ PipeConnectionUninitialize - free data in a pipe connection.
+
+*******************************************************************/
+void PipeConnectionUninitialize(
+    __in BURN_PIPE_CONNECTION* pConnection
+    )
+{
+    ReleaseFileHandle(pConnection->hCachePipe);
+    ReleaseFileHandle(pConnection->hPipe);
+    ReleaseHandle(pConnection->hProcess);
+    ReleaseStr(pConnection->sczSecret);
+    ReleaseStr(pConnection->sczName);
+
+    memset(pConnection, 0, sizeof(BURN_PIPE_CONNECTION));
+    pConnection->hPipe = INVALID_HANDLE_VALUE;
+    pConnection->hCachePipe = INVALID_HANDLE_VALUE;
+}
+
+/*******************************************************************
+ PipeSendMessage - 
+
+*******************************************************************/
+extern "C" HRESULT PipeSendMessage(
+    __in HANDLE hPipe,
+    __in DWORD dwMessage,
+    __in_bcount_opt(cbData) LPVOID pvData,
+    __in DWORD cbData,
+    __in_opt PFN_PIPE_MESSAGE_CALLBACK pfnCallback,
+    __in_opt LPVOID pvContext,
+    __out DWORD* pdwResult
+    )
+{
+    HRESULT hr = S_OK;
+    BURN_PIPE_RESULT result = { };
+
+    hr = WritePipeMessage(hPipe, dwMessage, pvData, cbData);
+    ExitOnFailure(hr, "Failed to write send message to pipe.");
+
+    hr = PipePumpMessages(hPipe, pfnCallback, pvContext, &result);
+    ExitOnFailure(hr, "Failed to pump messages during send message to pipe.");
+
+    *pdwResult = result.dwResult;
+
+LExit:
+    return hr;
+}
+
+/*******************************************************************
+ PipePumpMessages - 
+
+*******************************************************************/
+extern "C" HRESULT PipePumpMessages(
+    __in HANDLE hPipe,
+    __in_opt PFN_PIPE_MESSAGE_CALLBACK pfnCallback,
+    __in_opt LPVOID pvContext,
+    __in BURN_PIPE_RESULT* pResult
+    )
+{
+    HRESULT hr = S_OK;
+    BURN_PIPE_MESSAGE msg = { };
+    SIZE_T iData = 0;
+    LPSTR sczMessage = NULL;
+    DWORD dwResult = 0;
+
+    // Pump messages from child process.
+    while (S_OK == (hr = GetPipeMessage(hPipe, &msg)))
+    {
+        switch (msg.dwMessage)
+        {
+        case BURN_PIPE_MESSAGE_TYPE_LOG:
+            iData = 0;
+
+            hr = BuffReadStringAnsi((BYTE*)msg.pvData, msg.cbData, &iData, &sczMessage);
+            ExitOnFailure(hr, "Failed to read log message.");
+
+            hr = LogStringWorkRaw(sczMessage);
+            ExitOnFailure(hr, "Failed to write log message:'%hs'.", sczMessage);
+
+            dwResult = static_cast<DWORD>(hr);
+            break;
+
+        case BURN_PIPE_MESSAGE_TYPE_COMPLETE:
+            if (!msg.pvData || sizeof(DWORD) != msg.cbData)
+            {
+                hr = E_INVALIDARG;
+                ExitOnRootFailure(hr, "No status returned to PipePumpMessages()");
+            }
+
+            pResult->dwResult = *static_cast<DWORD*>(msg.pvData);
+            ExitFunction1(hr = S_OK); // exit loop.
+
+        case BURN_PIPE_MESSAGE_TYPE_TERMINATE:
+            iData = 0;
+
+            hr = BuffReadNumber(static_cast<BYTE*>(msg.pvData), msg.cbData, &iData, &pResult->dwResult);
+            ExitOnFailure(hr, "Failed to read returned result to PipePumpMessages()");
+
+            if (sizeof(DWORD) * 2 == msg.cbData)
+            {
+                hr = BuffReadNumber(static_cast<BYTE*>(msg.pvData), msg.cbData, &iData, (DWORD*)&pResult->fRestart);
+                ExitOnFailure(hr, "Failed to read returned restart to PipePumpMessages()");
+            }
+
+            ExitFunction1(hr = S_OK); // exit loop.
+
+        default:
+            if (pfnCallback)
+            {
+                hr = pfnCallback(&msg, pvContext, &dwResult);
+            }
+            else
+            {
+                hr = E_INVALIDARG;
+            }
+            ExitOnFailure(hr, "Failed to process message: %u", msg.dwMessage);
+            break;
+        }
+
+        // post result
+        hr = WritePipeMessage(hPipe, static_cast<DWORD>(BURN_PIPE_MESSAGE_TYPE_COMPLETE), &dwResult, sizeof(dwResult));
+        ExitOnFailure(hr, "Failed to post result to child process.");
+
+        FreePipeMessage(&msg);
+    }
+    ExitOnFailure(hr, "Failed to get message over pipe");
+
+    if (S_FALSE == hr)
+    {
+        hr = S_OK;
+    }
+
+LExit:
+    ReleaseStr(sczMessage);
+    FreePipeMessage(&msg);
+
+    return hr;
+}
+
+/*******************************************************************
+ PipeCreateNameAndSecret - 
+
+*******************************************************************/
+extern "C" HRESULT PipeCreateNameAndSecret(
+    __out_z LPWSTR *psczConnectionName,
+    __out_z LPWSTR *psczSecret
+    )
+{
+    HRESULT hr = S_OK;
+    WCHAR wzGuid[GUID_STRING_LENGTH];
+    LPWSTR sczConnectionName = NULL;
+    LPWSTR sczSecret = NULL;
+
+    // Create the unique pipe name.
+    hr = GuidFixedCreate(wzGuid);
+    ExitOnRootFailure(hr, "Failed to create pipe guid.");
+
+    hr = StrAllocFormatted(&sczConnectionName, L"BurnPipe.%s", wzGuid);
+    ExitOnFailure(hr, "Failed to allocate pipe name.");
+
+    // Create the unique client secret.
+    hr = GuidFixedCreate(wzGuid);
+    ExitOnRootFailure(hr, "Failed to create pipe secret.");
+
+    hr = StrAllocString(&sczSecret, wzGuid, 0);
+    ExitOnFailure(hr, "Failed to allocate pipe secret.");
+
+    *psczConnectionName = sczConnectionName;
+    sczConnectionName = NULL;
+    *psczSecret = sczSecret;
+    sczSecret = NULL;
+
+LExit:
+    ReleaseStr(sczSecret);
+    ReleaseStr(sczConnectionName);
+
+    return hr;
+}
+
+/*******************************************************************
+ PipeCreatePipes - create the pipes and event to signal child process.
+
+*******************************************************************/
+extern "C" HRESULT PipeCreatePipes(
+    __in BURN_PIPE_CONNECTION* pConnection,
+    __in BOOL fCreateCachePipe,
+    __out HANDLE* phEvent
+    )
+{
+    Assert(pConnection->sczName);
+    Assert(INVALID_HANDLE_VALUE == pConnection->hPipe);
+    Assert(INVALID_HANDLE_VALUE == pConnection->hCachePipe);
+
+    HRESULT hr = S_OK;
+    PSECURITY_DESCRIPTOR psd = NULL;
+    SECURITY_ATTRIBUTES sa = { };
+    LPWSTR sczFullPipeName = NULL;
+    HANDLE hPipe = INVALID_HANDLE_VALUE;
+    HANDLE hCachePipe = INVALID_HANDLE_VALUE;
+
+    // Only the grant special rights when the pipe is being used for "embedded"
+    // scenarios (aka: there is no cache pipe).
+    if (!fCreateCachePipe)
+    {
+        // Create the security descriptor that grants read/write/sync access to Everyone.
+        // TODO: consider locking down "WD" to LogonIds (logon session)
+        LPCWSTR wzSddl = L"D:(A;;GA;;;SY)(A;;GA;;;BA)(A;;GRGW0x00100000;;;WD)";
+        if (!::ConvertStringSecurityDescriptorToSecurityDescriptorW(wzSddl, SDDL_REVISION_1, &psd, NULL))
+        {
+            ExitWithLastError(hr, "Failed to create the security descriptor for the connection event and pipe.");
+        }
+
+        sa.nLength = sizeof(sa);
+        sa.lpSecurityDescriptor = psd;
+        sa.bInheritHandle = FALSE;
+    }
+
+    // Create the pipe.
+    hr = StrAllocFormatted(&sczFullPipeName, PIPE_NAME_FORMAT_STRING, pConnection->sczName);
+    ExitOnFailure(hr, "Failed to allocate full name of pipe: %ls", pConnection->sczName);
+
+    // TODO: consider using overlapped IO to do waits on the pipe and still be able to cancel and such.
+    hPipe = ::CreateNamedPipeW(sczFullPipeName, PIPE_ACCESS_DUPLEX | FILE_FLAG_FIRST_PIPE_INSTANCE, PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT, 1, PIPE_64KB, PIPE_64KB, 1, psd ? &sa : NULL);
+    if (INVALID_HANDLE_VALUE == hPipe)
+    {
+        ExitWithLastError(hr, "Failed to create pipe: %ls", sczFullPipeName);
+    }
+
+    if (fCreateCachePipe)
+    {
+        // Create the cache pipe.
+        hr = StrAllocFormatted(&sczFullPipeName, CACHE_PIPE_NAME_FORMAT_STRING, pConnection->sczName);
+        ExitOnFailure(hr, "Failed to allocate full name of cache pipe: %ls", pConnection->sczName);
+
+        hCachePipe = ::CreateNamedPipeW(sczFullPipeName, PIPE_ACCESS_DUPLEX | FILE_FLAG_FIRST_PIPE_INSTANCE, PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT, 1, PIPE_64KB, PIPE_64KB, 1, NULL);
+        if (INVALID_HANDLE_VALUE == hCachePipe)
+        {
+            ExitWithLastError(hr, "Failed to create pipe: %ls", sczFullPipeName);
+        }
+    }
+
+    pConnection->hCachePipe = hCachePipe;
+    hCachePipe = INVALID_HANDLE_VALUE;
+
+    pConnection->hPipe = hPipe;
+    hPipe = INVALID_HANDLE_VALUE;
+
+    // TODO: remove the following
+    *phEvent = NULL;
+
+LExit:
+    ReleaseFileHandle(hCachePipe);
+    ReleaseFileHandle(hPipe);
+    ReleaseStr(sczFullPipeName);
+
+    if (psd)
+    {
+        ::LocalFree(psd);
+    }
+
+    return hr;
+}
+
+/*******************************************************************
+ PipeLaunchParentProcess - Called from the per-machine process to create
+                           a per-user process and set up the
+                           communication pipe.
+
+*******************************************************************/
+const LPCWSTR BURN_COMMANDLINE_SWITCH_UNELEVATED = L"burn.unelevated";
+HRESULT PipeLaunchParentProcess(
+    __in_z LPCWSTR wzCommandLine,
+    __in int nCmdShow,
+    __in_z LPWSTR sczConnectionName,
+    __in_z LPWSTR sczSecret,
+    __in BOOL /*fDisableUnelevate*/
+    )
+{
+    HRESULT hr = S_OK;
+    DWORD dwProcessId = 0;
+    LPWSTR sczBurnPath = NULL;
+    LPWSTR sczParameters = NULL;
+    HANDLE hProcess = NULL;
+
+    dwProcessId = ::GetCurrentProcessId();
+
+    hr = PathForCurrentProcess(&sczBurnPath, NULL);
+    ExitOnFailure(hr, "Failed to get current process path.");
+
+    hr = StrAllocFormatted(&sczParameters, L"-%ls %ls %ls %u %ls", BURN_COMMANDLINE_SWITCH_UNELEVATED, sczConnectionName, sczSecret, dwProcessId, wzCommandLine);
+    ExitOnFailure(hr, "Failed to allocate parameters for unelevated process.");
+
+#ifdef ENABLE_UNELEVATE
+    if (fDisableUnelevate)
+    {
+        hr = ProcExec(sczBurnPath, sczParameters, nCmdShow, &hProcess);
+        ExitOnFailure(hr, "Failed to launch parent process with unelevate disabled: %ls", sczBurnPath);
+    }
+    else
+    {
+        // Try to launch unelevated and if that fails for any reason, try launch our process normally (even though that may make it elevated).
+        hr = ProcExecuteAsInteractiveUser(sczBurnPath, sczParameters, &hProcess);
+        if (FAILED(hr))
+        {
+            hr = ShelExecUnelevated(sczBurnPath, sczParameters, L"open", NULL, nCmdShow);
+            if (FAILED(hr))
+            {
+                hr = ShelExec(sczBurnPath, sczParameters, L"open", NULL, nCmdShow, NULL, NULL);
+                ExitOnFailure(hr, "Failed to launch parent process: %ls", sczBurnPath);
+            }
+        }
+    }
+#else
+    hr = ProcExec(sczBurnPath, sczParameters, nCmdShow, &hProcess);
+    ExitOnFailure(hr, "Failed to launch parent process with unelevate disabled: %ls", sczBurnPath);
+#endif
+
+LExit:
+    ReleaseHandle(hProcess);
+    ReleaseStr(sczParameters);
+    ReleaseStr(sczBurnPath);
+
+    return hr;
+}
+
+/*******************************************************************
+ PipeLaunchChildProcess - Called from the per-user process to create
+                          the per-machine process and set up the
+                          communication pipe.
+
+*******************************************************************/
+extern "C" HRESULT PipeLaunchChildProcess(
+    __in_z LPCWSTR wzExecutablePath,
+    __in BURN_PIPE_CONNECTION* pConnection,
+    __in BOOL fElevate,
+    __in_opt HWND hwndParent
+    )
+{
+    HRESULT hr = S_OK;
+    DWORD dwCurrentProcessId = ::GetCurrentProcessId();
+    LPWSTR sczParameters = NULL;
+    OS_VERSION osVersion = OS_VERSION_UNKNOWN;
+    DWORD dwServicePack = 0;
+    LPCWSTR wzVerb = NULL;
+    HANDLE hProcess = NULL;
+
+    hr = StrAllocFormatted(&sczParameters, L"-q -%ls %ls %ls %u", BURN_COMMANDLINE_SWITCH_ELEVATED, pConnection->sczName, pConnection->sczSecret, dwCurrentProcessId);
+    ExitOnFailure(hr, "Failed to allocate parameters for elevated process.");
+
+    OsGetVersion(&osVersion, &dwServicePack);
+    wzVerb = (OS_VERSION_VISTA > osVersion) || !fElevate ? L"open" : L"runas";
+
+    // Since ShellExecuteEx doesn't support passing inherited handles, don't bother with CoreAppendFileHandleSelfToCommandLine.
+    // We could fallback to using ::DuplicateHandle to inject the file handle later if necessary.
+    hr = ShelExec(wzExecutablePath, sczParameters, wzVerb, NULL, SW_HIDE, hwndParent, &hProcess);
+    ExitOnFailure(hr, "Failed to launch elevated child process: %ls", wzExecutablePath);
+
+    pConnection->dwProcessId = ::GetProcessId(hProcess);
+    pConnection->hProcess = hProcess;
+    hProcess = NULL;
+
+LExit:
+    ReleaseHandle(hProcess);
+    ReleaseStr(sczParameters);
+
+    return hr;
+}
+
+/*******************************************************************
+ PipeWaitForChildConnect - 
+
+*******************************************************************/
+extern "C" HRESULT PipeWaitForChildConnect(
+    __in BURN_PIPE_CONNECTION* pConnection
+    )
+{
+    HRESULT hr = S_OK;
+    HANDLE hPipes[2] = { pConnection->hPipe, pConnection->hCachePipe};
+    LPCWSTR wzSecret = pConnection->sczSecret;
+    DWORD cbSecret = lstrlenW(wzSecret) * sizeof(WCHAR);
+    DWORD dwCurrentProcessId = ::GetCurrentProcessId();
+    DWORD dwAck = 0;
+    DWORD cb = 0;
+
+    for (DWORD i = 0; i < countof(hPipes) && INVALID_HANDLE_VALUE != hPipes[i]; ++i)
+    {
+        HANDLE hPipe = hPipes[i];
+        DWORD dwPipeState = PIPE_READMODE_BYTE | PIPE_NOWAIT;
+
+        // Temporarily make the pipe non-blocking so we will not get stuck in ::ConnectNamedPipe() forever
+        // if the child decides not to show up.
+        if (!::SetNamedPipeHandleState(hPipe, &dwPipeState, NULL, NULL))
+        {
+            ExitWithLastError(hr, "Failed to set pipe to non-blocking.");
+        }
+
+        // Loop for a while waiting for a connection from child process.
+        DWORD cRetry = 0;
+        do
+        {
+            if (!::ConnectNamedPipe(hPipe, NULL))
+            {
+                DWORD er = ::GetLastError();
+                if (ERROR_PIPE_CONNECTED == er)
+                {
+                    hr = S_OK;
+                    break;
+                }
+                else if (ERROR_PIPE_LISTENING == er)
+                {
+                    if (cRetry < PIPE_RETRY_FOR_CONNECTION)
+                    {
+                        hr = HRESULT_FROM_WIN32(er);
+                    }
+                    else
+                    {
+                        hr = HRESULT_FROM_WIN32(ERROR_TIMEOUT);
+                        break;
+                    }
+
+                    ++cRetry;
+                    ::Sleep(PIPE_WAIT_FOR_CONNECTION);
+                }
+                else
+                {
+                    hr = HRESULT_FROM_WIN32(er);
+                    break;
+                }
+            }
+        } while (HRESULT_FROM_WIN32(ERROR_PIPE_LISTENING) == hr);
+        ExitOnRootFailure(hr, "Failed to wait for child to connect to pipe.");
+
+        // Put the pipe back in blocking mode.
+        dwPipeState = PIPE_READMODE_BYTE | PIPE_WAIT;
+        if (!::SetNamedPipeHandleState(hPipe, &dwPipeState, NULL, NULL))
+        {
+            ExitWithLastError(hr, "Failed to reset pipe to blocking.");
+        }
+
+        // Prove we are the one that created the elevated process by passing the secret.
+        if (!::WriteFile(hPipe, &cbSecret, sizeof(cbSecret), &cb, NULL))
+        {
+            ExitWithLastError(hr, "Failed to write secret length to pipe.");
+        }
+
+        if (!::WriteFile(hPipe, wzSecret, cbSecret, &cb, NULL))
+        {
+            ExitWithLastError(hr, "Failed to write secret to pipe.");
+        }
+
+        if (!::WriteFile(hPipe, &dwCurrentProcessId, sizeof(dwCurrentProcessId), &cb, NULL))
+        {
+            ExitWithLastError(hr, "Failed to write our process id to pipe.");
+        }
+
+        // Wait until the elevated process responds that it is ready to go.
+        if (!::ReadFile(hPipe, &dwAck, sizeof(dwAck), &cb, NULL))
+        {
+            ExitWithLastError(hr, "Failed to read ACK from pipe.");
+        }
+
+        // The ACK should match out expected child process id.
+        //if (pConnection->dwProcessId != dwAck)
+        //{
+        //    hr = HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
+        //    ExitOnRootFailure(hr, "Incorrect ACK from elevated pipe: %u", dwAck);
+        //}
+    }
+
+LExit:
+    return hr;
+}
+
+/*******************************************************************
+ PipeTerminateChildProcess - 
+
+*******************************************************************/
+extern "C" HRESULT PipeTerminateChildProcess(
+    __in BURN_PIPE_CONNECTION* pConnection,
+    __in DWORD dwParentExitCode,
+    __in BOOL fRestart
+    )
+{
+    HRESULT hr = S_OK;
+    BYTE* pbData = NULL;
+    SIZE_T cbData = 0;
+
+    // Prepare the exit message.
+    hr = BuffWriteNumber(&pbData, &cbData, dwParentExitCode);
+    ExitOnFailure(hr, "Failed to write exit code to message buffer.");
+
+    hr = BuffWriteNumber(&pbData, &cbData, fRestart);
+    ExitOnFailure(hr, "Failed to write restart to message buffer.");
+
+    // Send the messages.
+    if (INVALID_HANDLE_VALUE != pConnection->hCachePipe)
+    {
+        hr = WritePipeMessage(pConnection->hCachePipe, static_cast<DWORD>(BURN_PIPE_MESSAGE_TYPE_TERMINATE), pbData, cbData);
+        ExitOnFailure(hr, "Failed to post terminate message to child process cache thread.");
+    }
+
+    hr = WritePipeMessage(pConnection->hPipe, static_cast<DWORD>(BURN_PIPE_MESSAGE_TYPE_TERMINATE), pbData, cbData);
+    ExitOnFailure(hr, "Failed to post terminate message to child process.");
+
+    // If we were able to get a handle to the other process, wait for it to exit.
+    if (pConnection->hProcess)
+    {
+        if (WAIT_FAILED == ::WaitForSingleObject(pConnection->hProcess, PIPE_WAIT_FOR_CONNECTION * PIPE_RETRY_FOR_CONNECTION))
+        {
+            ExitWithLastError(hr, "Failed to wait for child process exit.");
+        }
+
+#ifdef DEBUG
+        DWORD dwChildExitCode = 0;
+        DWORD dwErrorCode = ERROR_SUCCESS;
+        BOOL fReturnedExitCode = ::GetExitCodeProcess(pConnection->hProcess, &dwChildExitCode);
+        if (!fReturnedExitCode)
+        {
+            dwErrorCode = ::GetLastError(); // if the other process is elevated and we are not, then we'll get ERROR_ACCESS_DENIED.
+
+            // The unit test use a thread instead of a process so try to get the exit code from
+            // the thread because we failed to get it from the process.
+            if (ERROR_INVALID_HANDLE == dwErrorCode)
+            {
+                fReturnedExitCode = ::GetExitCodeThread(pConnection->hProcess, &dwChildExitCode);
+            }
+        }
+        AssertSz((fReturnedExitCode && dwChildExitCode == dwParentExitCode) ||
+                 (!fReturnedExitCode && ERROR_ACCESS_DENIED == dwErrorCode),
+                 "Child elevated process did not return matching exit code to parent process.");
+#endif
+    }
+
+LExit:
+    return hr;
+}
+
+/*******************************************************************
+ PipeChildConnect - Called from the child process to connect back
+                    to the pipe provided by the parent process.
+
+*******************************************************************/
+extern "C" HRESULT PipeChildConnect(
+    __in BURN_PIPE_CONNECTION* pConnection,
+    __in BOOL fConnectCachePipe
+    )
+{
+    Assert(pConnection->sczName);
+    Assert(pConnection->sczSecret);
+    Assert(!pConnection->hProcess);
+    Assert(INVALID_HANDLE_VALUE == pConnection->hPipe);
+    Assert(INVALID_HANDLE_VALUE == pConnection->hCachePipe);
+
+    HRESULT hr = S_OK;
+    LPWSTR sczPipeName = NULL;
+
+    // Try to connect to the parent.
+    hr = StrAllocFormatted(&sczPipeName, PIPE_NAME_FORMAT_STRING, pConnection->sczName);
+    ExitOnFailure(hr, "Failed to allocate name of parent pipe.");
+
+    hr = E_UNEXPECTED;
+    for (DWORD cRetry = 0; FAILED(hr) && cRetry < PIPE_RETRY_FOR_CONNECTION; ++cRetry)
+    {
+        pConnection->hPipe = ::CreateFileW(sczPipeName, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
+        if (INVALID_HANDLE_VALUE == pConnection->hPipe)
+        {
+            hr = HRESULT_FROM_WIN32(::GetLastError());
+            if (E_FILENOTFOUND == hr) // if the pipe isn't created, call it a timeout waiting on the parent.
+            {
+                hr = HRESULT_FROM_WIN32(ERROR_TIMEOUT);
+            }
+
+            ::Sleep(PIPE_WAIT_FOR_CONNECTION);
+        }
+        else // we have a connection, go with it.
+        {
+            hr = S_OK;
+        }
+    }
+    ExitOnRootFailure(hr, "Failed to open parent pipe: %ls", sczPipeName)
+
+    // Verify the parent and notify it that the child connected.
+    hr = ChildPipeConnected(pConnection->hPipe, pConnection->sczSecret, &pConnection->dwProcessId);
+    ExitOnFailure(hr, "Failed to verify parent pipe: %ls", sczPipeName);
+
+    if (fConnectCachePipe)
+    {
+        // Connect to the parent for the cache pipe.
+        hr = StrAllocFormatted(&sczPipeName, CACHE_PIPE_NAME_FORMAT_STRING, pConnection->sczName);
+        ExitOnFailure(hr, "Failed to allocate name of parent cache pipe.");
+
+        pConnection->hCachePipe = ::CreateFileW(sczPipeName, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
+        if (INVALID_HANDLE_VALUE == pConnection->hCachePipe)
+        {
+            ExitWithLastError(hr, "Failed to open parent pipe: %ls", sczPipeName)
+        }
+
+        // Verify the parent and notify it that the child connected.
+        hr = ChildPipeConnected(pConnection->hCachePipe, pConnection->sczSecret, &pConnection->dwProcessId);
+        ExitOnFailure(hr, "Failed to verify parent pipe: %ls", sczPipeName);
+    }
+
+    pConnection->hProcess = ::OpenProcess(SYNCHRONIZE, FALSE, pConnection->dwProcessId);
+    ExitOnNullWithLastError(pConnection->hProcess, hr, "Failed to open companion process with PID: %u", pConnection->dwProcessId);
+
+LExit:
+    ReleaseStr(sczPipeName);
+
+    return hr;
+}
+
+
+static HRESULT AllocatePipeMessage(
+    __in DWORD dwMessage,
+    __in_bcount_opt(cbData) LPVOID pvData,
+    __in DWORD cbData,
+    __out_bcount(cb) LPVOID* ppvMessage,
+    __out DWORD* cbMessage
+    )
+{
+    HRESULT hr = S_OK;
+    LPVOID pv = NULL;
+    DWORD cb = 0;
+
+    // If no data was provided, ensure the count of bytes is zero.
+    if (!pvData)
+    {
+        cbData = 0;
+    }
+
+    // Allocate the message.
+    cb = sizeof(dwMessage) + sizeof(cbData) + cbData;
+    pv = MemAlloc(cb, FALSE);
+    ExitOnNull(pv, hr, E_OUTOFMEMORY, "Failed to allocate memory for message.");
+
+    memcpy_s(pv, cb, &dwMessage, sizeof(dwMessage));
+    memcpy_s(static_cast<BYTE*>(pv) + sizeof(dwMessage), cb - sizeof(dwMessage), &cbData, sizeof(cbData));
+    if (cbData)
+    {
+        memcpy_s(static_cast<BYTE*>(pv) + sizeof(dwMessage) + sizeof(cbData), cb - sizeof(dwMessage) - sizeof(cbData), pvData, cbData);
+    }
+
+    *cbMessage = cb;
+    *ppvMessage = pv;
+    pv = NULL;
+
+LExit:
+    ReleaseMem(pv);
+    return hr;
+}
+
+static void FreePipeMessage(
+    __in BURN_PIPE_MESSAGE *pMsg
+    )
+{
+    if (pMsg->fAllocatedData)
+    {
+        ReleaseNullMem(pMsg->pvData);
+        pMsg->fAllocatedData = FALSE;
+    }
+}
+
+static HRESULT WritePipeMessage(
+    __in HANDLE hPipe,
+    __in DWORD dwMessage,
+    __in_bcount_opt(cbData) LPVOID pvData,
+    __in DWORD cbData
+    )
+{
+    HRESULT hr = S_OK;
+    LPVOID pv = NULL;
+    DWORD cb = 0;
+
+    hr = AllocatePipeMessage(dwMessage, pvData, cbData, &pv, &cb);
+    ExitOnFailure(hr, "Failed to allocate message to write.");
+
+    // Write the message.
+    DWORD cbWrote = 0;
+    DWORD cbTotalWritten = 0;
+    while (cbTotalWritten < cb)
+    {
+        if (!::WriteFile(hPipe, pv, cb - cbTotalWritten, &cbWrote, NULL))
+        {
+            ExitWithLastError(hr, "Failed to write message type to pipe.");
+        }
+
+        cbTotalWritten += cbWrote;
+    }
+
+LExit:
+    ReleaseMem(pv);
+    return hr;
+}
+
+static HRESULT GetPipeMessage(
+    __in HANDLE hPipe,
+    __in BURN_PIPE_MESSAGE* pMsg
+    )
+{
+    HRESULT hr = S_OK;
+    DWORD rgdwMessageAndByteCount[2] = { };
+    DWORD cb = 0;
+    DWORD cbRead = 0;
+
+    while (cbRead < sizeof(rgdwMessageAndByteCount))
+    {
+        if (!::ReadFile(hPipe, reinterpret_cast<BYTE*>(rgdwMessageAndByteCount) + cbRead, sizeof(rgdwMessageAndByteCount) - cbRead, &cb, NULL))
+        {
+            DWORD er = ::GetLastError();
+            if (ERROR_MORE_DATA == er)
+            {
+                hr = S_OK;
+            }
+            else if (ERROR_BROKEN_PIPE == er) // parent process shut down, time to exit.
+            {
+                memset(rgdwMessageAndByteCount, 0, sizeof(rgdwMessageAndByteCount));
+                hr = S_FALSE;
+                break;
+            }
+            else
+            {
+                hr = HRESULT_FROM_WIN32(er);
+            }
+            ExitOnRootFailure(hr, "Failed to read message from pipe.");
+        }
+
+        cbRead += cb;
+    }
+
+    pMsg->dwMessage = rgdwMessageAndByteCount[0];
+    pMsg->cbData = rgdwMessageAndByteCount[1];
+    if (pMsg->cbData)
+    {
+        pMsg->pvData = MemAlloc(pMsg->cbData, FALSE);
+        ExitOnNull(pMsg->pvData, hr, E_OUTOFMEMORY, "Failed to allocate data for message.");
+
+        if (!::ReadFile(hPipe, pMsg->pvData, pMsg->cbData, &cb, NULL))
+        {
+            ExitWithLastError(hr, "Failed to read data for message.");
+        }
+
+        pMsg->fAllocatedData = TRUE;
+    }
+
+LExit:
+    if (!pMsg->fAllocatedData && pMsg->pvData)
+    {
+        MemFree(pMsg->pvData);
+    }
+
+    return hr;
+}
+
+static HRESULT ChildPipeConnected(
+    __in HANDLE hPipe,
+    __in_z LPCWSTR wzSecret,
+    __inout DWORD* pdwProcessId
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR sczVerificationSecret = NULL;
+    DWORD cbVerificationSecret = 0;
+    DWORD dwVerificationProcessId = 0;
+    DWORD dwRead = 0;
+    DWORD dwAck = ::GetCurrentProcessId(); // send our process id as the ACK.
+    DWORD cb = 0;
+
+    // Read the verification secret.
+    if (!::ReadFile(hPipe, &cbVerificationSecret, sizeof(cbVerificationSecret), &dwRead, NULL))
+    {
+        ExitWithLastError(hr, "Failed to read size of verification secret from parent pipe.");
+    }
+
+    if (255 < cbVerificationSecret / sizeof(WCHAR))
+    {
+        hr = HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
+        ExitOnRootFailure(hr, "Verification secret from parent is too big.");
+    }
+
+    hr = StrAlloc(&sczVerificationSecret, cbVerificationSecret / sizeof(WCHAR) + 1);
+    ExitOnFailure(hr, "Failed to allocate buffer for verification secret.");
+
+    if (!::ReadFile(hPipe, sczVerificationSecret, cbVerificationSecret, &dwRead, NULL))
+    {
+        ExitWithLastError(hr, "Failed to read verification secret from parent pipe.");
+    }
+
+    // Verify the secrets match.
+    if (CSTR_EQUAL != ::CompareStringW(LOCALE_NEUTRAL, 0, sczVerificationSecret, -1, wzSecret, -1))
+    {
+        hr = HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
+        ExitOnRootFailure(hr, "Verification secret from parent does not match.");
+    }
+
+    // Read the verification process id.
+    if (!::ReadFile(hPipe, &dwVerificationProcessId, sizeof(dwVerificationProcessId), &dwRead, NULL))
+    {
+        ExitWithLastError(hr, "Failed to read verification process id from parent pipe.");
+    }
+
+    // If a process id was not provided, we'll trust the process id from the parent.
+    if (*pdwProcessId == 0)
+    {
+        *pdwProcessId = dwVerificationProcessId;
+    }
+    else if (*pdwProcessId != dwVerificationProcessId) // verify the ids match.
+    {
+        hr = HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
+        ExitOnRootFailure(hr, "Verification process id from parent does not match.");
+    }
+
+    // All is well, tell the parent process.
+    if (!::WriteFile(hPipe, &dwAck, sizeof(dwAck), &cb, NULL))
+    {
+        ExitWithLastError(hr, "Failed to inform parent process that child is running.");
+    }
+
+LExit:
+    ReleaseStr(sczVerificationSecret);
+    return hr;
+}
diff --git a/src/engine/pipe.h b/src/engine/pipe.h
new file mode 100644
index 00000000..b6a7742a
--- /dev/null
+++ b/src/engine/pipe.h
@@ -0,0 +1,113 @@
+#pragma once
+// 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.
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct _BURN_PIPE_CONNECTION
+{
+    LPWSTR sczName;
+    LPWSTR sczSecret;
+    DWORD dwProcessId;
+
+    HANDLE hProcess;
+    HANDLE hPipe;
+    HANDLE hCachePipe;
+} BURN_PIPE_CONNECTION;
+
+typedef enum _BURN_PIPE_MESSAGE_TYPE
+{
+    BURN_PIPE_MESSAGE_TYPE_LOG = 0xF0000001,
+    BURN_PIPE_MESSAGE_TYPE_COMPLETE = 0xF0000002,
+    BURN_PIPE_MESSAGE_TYPE_TERMINATE = 0xF0000003,
+} BURN_PIPE_MESSAGE_TYPE;
+
+typedef struct _BURN_PIPE_MESSAGE
+{
+    DWORD dwMessage;
+    DWORD cbData;
+
+    BOOL fAllocatedData;
+    LPVOID pvData;
+} BURN_PIPE_MESSAGE;
+
+typedef struct _BURN_PIPE_RESULT
+{
+    DWORD dwResult;
+    BOOL fRestart;
+} BURN_PIPE_RESULT;
+
+
+typedef HRESULT (*PFN_PIPE_MESSAGE_CALLBACK)(
+    __in BURN_PIPE_MESSAGE* pMsg,
+    __in_opt LPVOID pvContext,
+    __out DWORD* pdwResult
+    );
+
+
+// Common functions.
+void PipeConnectionInitialize(
+    __in BURN_PIPE_CONNECTION* pConnection
+    );
+void PipeConnectionUninitialize(
+    __in BURN_PIPE_CONNECTION* pConnection
+    );
+HRESULT PipeSendMessage(
+    __in HANDLE hPipe,
+    __in DWORD dwMessage,
+    __in_bcount_opt(cbData) LPVOID pvData,
+    __in DWORD cbData,
+    __in_opt PFN_PIPE_MESSAGE_CALLBACK pfnCallback,
+    __in_opt LPVOID pvContext,
+    __out DWORD* pdwResult
+    );
+HRESULT PipePumpMessages(
+    __in HANDLE hPipe,
+    __in_opt PFN_PIPE_MESSAGE_CALLBACK pfnCallback,
+    __in_opt LPVOID pvContext,
+    __in BURN_PIPE_RESULT* pResult
+    );
+
+// Parent functions.
+HRESULT PipeCreateNameAndSecret(
+    __out_z LPWSTR *psczConnectionName,
+    __out_z LPWSTR *psczSecret
+    );
+HRESULT PipeCreatePipes(
+    __in BURN_PIPE_CONNECTION* pConnection,
+    __in BOOL fCreateCachePipe,
+    __out HANDLE* phEvent
+    );
+HRESULT PipeLaunchParentProcess(
+    __in LPCWSTR wzCommandLine,
+    __in int nCmdShow,
+    __in_z LPWSTR sczConnectionName,
+    __in_z LPWSTR sczSecret,
+    __in BOOL fDisableUnelevate
+    );
+HRESULT PipeLaunchChildProcess(
+    __in_z LPCWSTR wzExecutablePath,
+    __in BURN_PIPE_CONNECTION* pConnection,
+    __in BOOL fElevate,
+    __in_opt HWND hwndParent
+    );
+HRESULT PipeWaitForChildConnect(
+    __in BURN_PIPE_CONNECTION* pConnection
+    );
+HRESULT PipeTerminateChildProcess(
+    __in BURN_PIPE_CONNECTION* pConnection,
+    __in DWORD dwParentExitCode,
+    __in BOOL fRestart
+    );
+
+// Child functions.
+HRESULT PipeChildConnect(
+    __in BURN_PIPE_CONNECTION* pConnection,
+    __in BOOL fConnectCachePipe
+    );
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/engine/plan.cpp b/src/engine/plan.cpp
new file mode 100644
index 00000000..01c7a31d
--- /dev/null
+++ b/src/engine/plan.cpp
@@ -0,0 +1,3169 @@
+// 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.
+
+#include "precomp.h"
+
+// internal struct definitions
+
+struct PLAN_NONPERMANENT_PACKAGE_INDICES
+{
+    DWORD iAfterExecuteFirstNonPermanentPackage;
+    DWORD iBeforeRollbackFirstNonPermanentPackage;
+    DWORD iAfterExecuteLastNonPermanentPackage;
+    DWORD iAfterRollbackLastNonPermanentPackage;
+};
+
+// internal function definitions
+
+static void UninitializeRegistrationAction(
+    __in BURN_DEPENDENT_REGISTRATION_ACTION* pAction
+    );
+static void UninitializeCacheAction(
+    __in BURN_CACHE_ACTION* pCacheAction
+    );
+static void ResetPlannedPackageState(
+    __in BURN_PACKAGE* pPackage
+    );
+static HRESULT ProcessPackage(
+    __in BOOL fBundlePerMachine,
+    __in BURN_PACKAGE* pCompatiblePackageParent,
+    __in BURN_USER_EXPERIENCE* pUX,
+    __in BURN_PLAN* pPlan,
+    __in BURN_PACKAGE* pPackage,
+    __in BURN_LOGGING* pLog,
+    __in BURN_VARIABLES* pVariables,
+    __in BOOTSTRAPPER_DISPLAY display,
+    __in BOOTSTRAPPER_RELATION_TYPE relationType,
+    __in_z_opt LPCWSTR wzLayoutDirectory,
+    __inout HANDLE* phSyncpointEvent,
+    __inout BURN_ROLLBACK_BOUNDARY** ppRollbackBoundary,
+    __in_opt PLAN_NONPERMANENT_PACKAGE_INDICES* pNonpermanentPackageIndices
+    );
+static HRESULT ProcessPackageRollbackBoundary(
+    __in BURN_PLAN* pPlan,
+    __in_opt BURN_ROLLBACK_BOUNDARY* pEffectiveRollbackBoundary,
+    __inout BURN_ROLLBACK_BOUNDARY** ppRollbackBoundary
+    );
+static HRESULT GetActionDefaultRequestState(
+    __in BOOTSTRAPPER_ACTION action,
+    __in BOOL fPermanent,
+    __in BOOTSTRAPPER_PACKAGE_STATE currentState,
+    __out BOOTSTRAPPER_REQUEST_STATE* pRequestState
+    );
+static HRESULT AddRegistrationAction(
+    __in BURN_PLAN* pPlan,
+    __in BURN_DEPENDENT_REGISTRATION_ACTION_TYPE type,
+    __in_z LPCWSTR wzDependentProviderKey,
+    __in_z LPCWSTR wzOwnerBundleId
+    );
+static HRESULT AddCachePackage(
+    __in BURN_PLAN* pPlan,
+    __in BURN_PACKAGE* pPackage,
+    __out HANDLE* phSyncpointEvent
+    );
+static HRESULT AddCachePackageHelper(
+    __in BURN_PLAN* pPlan,
+    __in BURN_PACKAGE* pPackage,
+    __out HANDLE* phSyncpointEvent
+    );
+static HRESULT AddCacheSlipstreamMsps(
+    __in BURN_PLAN* pPlan,
+    __in BURN_PACKAGE* pPackage
+    );
+static BOOL AlreadyPlannedCachePackage(
+    __in BURN_PLAN* pPlan,
+    __in_z LPCWSTR wzPackageId,
+    __out HANDLE* phSyncpointEvent
+    );
+static DWORD GetNextCheckpointId();
+static HRESULT AppendCacheAction(
+    __in BURN_PLAN* pPlan,
+    __out BURN_CACHE_ACTION** ppCacheAction
+    );
+static HRESULT AppendRollbackCacheAction(
+    __in BURN_PLAN* pPlan,
+    __out BURN_CACHE_ACTION** ppCacheAction
+    );
+static HRESULT AppendLayoutContainerAction(
+    __in BURN_PLAN* pPlan,
+    __in_opt BURN_PACKAGE* pPackage,
+    __in DWORD iPackageStartAction,
+    __in BURN_CONTAINER* pContainer,
+    __in BOOL fContainerCached,
+    __in_z LPCWSTR wzLayoutDirectory
+    );
+static HRESULT AppendCacheOrLayoutPayloadAction(
+    __in BURN_PLAN* pPlan,
+    __in_opt BURN_PACKAGE* pPackage,
+    __in DWORD iPackageStartAction,
+    __in BURN_PAYLOAD* pPayload,
+    __in BOOL fPayloadCached,
+    __in_z_opt LPCWSTR wzLayoutDirectory
+    );
+static BOOL FindContainerCacheAction(
+    __in BURN_CACHE_ACTION_TYPE type,
+    __in BURN_PLAN* pPlan,
+    __in BURN_CONTAINER* pContainer,
+    __in DWORD iSearchStart,
+    __in DWORD iSearchEnd,
+    __out_opt BURN_CACHE_ACTION** ppCacheAction,
+    __out_opt DWORD* piCacheAction
+    );
+static HRESULT CreateContainerAcquireAndExtractAction(
+    __in BURN_PLAN* pPlan,
+    __in BURN_CONTAINER* pContainer,
+    __in DWORD iPackageStartAction,
+    __in BOOL fPayloadCached,
+    __out BURN_CACHE_ACTION** ppContainerExtractAction,
+    __out DWORD* piContainerTryAgainAction
+    );
+static HRESULT AddAcquireContainer(
+    __in BURN_PLAN* pPlan,
+    __in BURN_CONTAINER* pContainer,
+    __out_opt BURN_CACHE_ACTION** ppCacheAction,
+    __out_opt DWORD* piCacheAction
+    );
+static HRESULT AddExtractPayload(
+    __in BURN_CACHE_ACTION* pCacheAction,
+    __in_opt BURN_PACKAGE* pPackage,
+    __in BURN_PAYLOAD* pPayload,
+    __in_z LPCWSTR wzPayloadWorkingPath
+    );
+static BURN_CACHE_ACTION* ProcessSharedPayload(
+    __in BURN_PLAN* pPlan,
+    __in BURN_PAYLOAD* pPayload
+    );
+static HRESULT RemoveUnnecessaryActions(
+    __in BOOL fExecute,
+    __in BURN_EXECUTE_ACTION* rgActions,
+    __in DWORD cActions
+    );
+static HRESULT FinalizeSlipstreamPatchActions(
+    __in BOOL fExecute,
+    __in BURN_EXECUTE_ACTION* rgActions,
+    __in DWORD cActions
+    );
+static HRESULT PlanDependencyActions(
+    __in BOOL fBundlePerMachine,
+    __in BURN_PLAN* pPlan,
+    __in BURN_PACKAGE* pPackage
+    );
+static HRESULT CalculateExecuteActions(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in BURN_PACKAGE* pPackage,
+    __in BURN_VARIABLES* pVariables,
+    __out_opt BOOL* pfBARequestedCache
+    );
+static BOOL NeedsCache(
+    __in BURN_PLAN* pPlan,
+    __in BURN_PACKAGE* pPackage
+    );
+static HRESULT CreateContainerProgress(
+    __in BURN_PLAN* pPlan,
+    __in BURN_CONTAINER* pContainer,
+    __out BURN_CACHE_CONTAINER_PROGRESS** ppContainerProgress
+    );
+static HRESULT CreatePayloadProgress(
+    __in BURN_PLAN* pPlan,
+    __in BURN_PAYLOAD* pPayload,
+    __out BURN_CACHE_PAYLOAD_PROGRESS** ppPayloadProgress
+    );
+
+// function definitions
+
+extern "C" void PlanReset(
+    __in BURN_PLAN* pPlan,
+    __in BURN_PACKAGES* pPackages
+    )
+{
+    if (pPlan->rgRegistrationActions)
+    {
+        for (DWORD i = 0; i < pPlan->cRegistrationActions; ++i)
+        {
+            UninitializeRegistrationAction(&pPlan->rgRegistrationActions[i]);
+        }
+        MemFree(pPlan->rgRegistrationActions);
+    }
+
+    if (pPlan->rgRollbackRegistrationActions)
+    {
+        for (DWORD i = 0; i < pPlan->cRollbackRegistrationActions; ++i)
+        {
+            UninitializeRegistrationAction(&pPlan->rgRollbackRegistrationActions[i]);
+        }
+        MemFree(pPlan->rgRollbackRegistrationActions);
+    }
+
+    if (pPlan->rgCacheActions)
+    {
+        for (DWORD i = 0; i < pPlan->cCacheActions; ++i)
+        {
+            UninitializeCacheAction(&pPlan->rgCacheActions[i]);
+        }
+        MemFree(pPlan->rgCacheActions);
+    }
+
+    if (pPlan->rgExecuteActions)
+    {
+        for (DWORD i = 0; i < pPlan->cExecuteActions; ++i)
+        {
+            PlanUninitializeExecuteAction(&pPlan->rgExecuteActions[i]);
+        }
+        MemFree(pPlan->rgExecuteActions);
+    }
+
+    if (pPlan->rgRollbackActions)
+    {
+        for (DWORD i = 0; i < pPlan->cRollbackActions; ++i)
+        {
+            PlanUninitializeExecuteAction(&pPlan->rgRollbackActions[i]);
+        }
+        MemFree(pPlan->rgRollbackActions);
+    }
+
+    if (pPlan->rgCleanActions)
+    {
+        // Nothing needs to be freed inside clean actions today.
+        MemFree(pPlan->rgCleanActions);
+    }
+
+    if (pPlan->rgPlannedProviders)
+    {
+        ReleaseDependencyArray(pPlan->rgPlannedProviders, pPlan->cPlannedProviders);
+    }
+
+    if (pPlan->rgContainerProgress)
+    {
+        MemFree(pPlan->rgContainerProgress);
+    }
+
+    if (pPlan->shContainerProgress)
+    {
+        ReleaseDict(pPlan->shContainerProgress);
+    }
+
+    if (pPlan->rgPayloadProgress)
+    {
+        MemFree(pPlan->rgPayloadProgress);
+    }
+
+    if (pPlan->shPayloadProgress)
+    {
+        ReleaseDict(pPlan->shPayloadProgress);
+    }
+
+    memset(pPlan, 0, sizeof(BURN_PLAN));
+
+    // Reset the planned actions for each package.
+    if (pPackages->rgPackages)
+    {
+        for (DWORD i = 0; i < pPackages->cPackages; ++i)
+        {
+            ResetPlannedPackageState(&pPackages->rgPackages[i]);
+        }
+    }
+}
+
+extern "C" void PlanUninitializeExecuteAction(
+    __in BURN_EXECUTE_ACTION* pExecuteAction
+    )
+{
+    switch (pExecuteAction->type)
+    {
+    case BURN_EXECUTE_ACTION_TYPE_EXE_PACKAGE:
+        ReleaseStr(pExecuteAction->exePackage.sczIgnoreDependencies);
+        ReleaseStr(pExecuteAction->exePackage.sczAncestors);
+        break;
+
+    case BURN_EXECUTE_ACTION_TYPE_MSI_PACKAGE:
+        ReleaseStr(pExecuteAction->msiPackage.sczLogPath);
+        ReleaseMem(pExecuteAction->msiPackage.rgFeatures);
+        ReleaseMem(pExecuteAction->msiPackage.rgSlipstreamPatches);
+        ReleaseMem(pExecuteAction->msiPackage.rgOrderedPatches);
+        break;
+
+    case BURN_EXECUTE_ACTION_TYPE_MSP_TARGET:
+        ReleaseStr(pExecuteAction->mspTarget.sczTargetProductCode);
+        ReleaseStr(pExecuteAction->mspTarget.sczLogPath);
+        ReleaseMem(pExecuteAction->mspTarget.rgOrderedPatches);
+        break;
+
+    case BURN_EXECUTE_ACTION_TYPE_MSU_PACKAGE:
+        ReleaseStr(pExecuteAction->msuPackage.sczLogPath);
+        break;
+
+    case BURN_EXECUTE_ACTION_TYPE_SERVICE_STOP: __fallthrough;
+    case BURN_EXECUTE_ACTION_TYPE_SERVICE_START:
+        ReleaseStr(pExecuteAction->service.sczServiceName);
+        break;
+
+    case BURN_EXECUTE_ACTION_TYPE_PACKAGE_DEPENDENCY:
+        ReleaseStr(pExecuteAction->packageDependency.sczBundleProviderKey);
+        break;
+
+    case BURN_EXECUTE_ACTION_TYPE_COMPATIBLE_PACKAGE:
+        ReleaseStr(pExecuteAction->compatiblePackage.sczInstalledProductCode);
+        break;
+    }
+}
+
+extern "C" HRESULT PlanSetVariables(
+    __in BOOTSTRAPPER_ACTION action,
+    __in BURN_VARIABLES* pVariables
+    )
+{
+    HRESULT hr = S_OK;
+
+    hr = VariableSetNumeric(pVariables, BURN_BUNDLE_ACTION, action, TRUE);
+    ExitOnFailure(hr, "Failed to set the bundle action built-in variable.");
+
+LExit:
+    return hr;
+}
+
+extern "C" HRESULT PlanDefaultPackageRequestState(
+    __in BURN_PACKAGE_TYPE packageType,
+    __in BOOTSTRAPPER_PACKAGE_STATE currentState,
+    __in BOOL fPermanent,
+    __in BOOTSTRAPPER_ACTION action,
+    __in BURN_VARIABLES* pVariables,
+    __in_z_opt LPCWSTR wzInstallCondition,
+    __in BOOTSTRAPPER_RELATION_TYPE relationType,
+    __out BOOTSTRAPPER_REQUEST_STATE* pRequestState
+    )
+{
+    HRESULT hr = S_OK;
+    BOOTSTRAPPER_REQUEST_STATE defaultRequestState = BOOTSTRAPPER_REQUEST_STATE_NONE;
+    BOOL fCondition = FALSE;
+
+    // If doing layout, then always default to requesting the file be cached.
+    if (BOOTSTRAPPER_ACTION_LAYOUT == action)
+    {
+        *pRequestState = BOOTSTRAPPER_REQUEST_STATE_CACHE;
+    }
+    else if (BOOTSTRAPPER_RELATION_PATCH == relationType && BURN_PACKAGE_TYPE_MSP == packageType)
+    {
+        // For patch related bundles, only install a patch if currently absent during install, modify, or repair.
+        if (BOOTSTRAPPER_PACKAGE_STATE_ABSENT == currentState && BOOTSTRAPPER_ACTION_INSTALL <= action)
+        {
+            *pRequestState = BOOTSTRAPPER_REQUEST_STATE_PRESENT;
+        }
+        else
+        {
+            *pRequestState = BOOTSTRAPPER_REQUEST_STATE_NONE;
+        }
+    }
+    else if (BOOTSTRAPPER_PACKAGE_STATE_SUPERSEDED == currentState && BOOTSTRAPPER_ACTION_UNINSTALL != action)
+    {
+        // Superseded means the package is on the machine but not active, so only uninstall operations are allowed.
+        // All other operations do nothing.
+        *pRequestState = BOOTSTRAPPER_REQUEST_STATE_NONE;
+    }
+    else if (BOOTSTRAPPER_PACKAGE_STATE_OBSOLETE == currentState && !(BOOTSTRAPPER_ACTION_UNINSTALL == action && BURN_PACKAGE_TYPE_MSP == packageType))
+    {
+        // Obsolete means the package is not on the machine and should not be installed, *except* patches can be obsolete
+        // and present so allow them to be removed during uninstall. Everyone else, gets nothing.
+        *pRequestState = BOOTSTRAPPER_REQUEST_STATE_NONE;
+    }
+    else // pick the best option for the action state and install condition.
+    {
+        hr = GetActionDefaultRequestState(action, fPermanent, currentState, &defaultRequestState);
+        ExitOnFailure(hr, "Failed to get default request state for action.");
+
+        // If there is an install condition (and we're doing an install) evaluate the condition
+        // to determine whether to use the default request state or make the package absent.
+        if (BOOTSTRAPPER_ACTION_UNINSTALL != action && wzInstallCondition && *wzInstallCondition)
+        {
+            hr = ConditionEvaluate(pVariables, wzInstallCondition, &fCondition);
+            ExitOnFailure(hr, "Failed to evaluate install condition.");
+
+            *pRequestState = fCondition ? defaultRequestState : BOOTSTRAPPER_REQUEST_STATE_ABSENT;
+        }
+        else // just set the package to the default request state.
+        {
+            *pRequestState = defaultRequestState;
+        }
+    }
+
+LExit:
+    return hr;
+}
+
+extern "C" HRESULT PlanLayoutBundle(
+    __in BURN_PLAN* pPlan,
+    __in_z LPCWSTR wzExecutableName,
+    __in DWORD64 qwBundleSize,
+    __in BURN_VARIABLES* pVariables,
+    __in BURN_PAYLOADS* pPayloads,
+    __out_z LPWSTR* psczLayoutDirectory
+    )
+{
+    HRESULT hr = S_OK;
+    BURN_CACHE_ACTION* pCacheAction = NULL;
+    LPWSTR sczExecutablePath = NULL;
+    LPWSTR sczLayoutDirectory = NULL;
+
+    // Get the layout directory.
+    hr = VariableGetString(pVariables, BURN_BUNDLE_LAYOUT_DIRECTORY, &sczLayoutDirectory);
+    if (E_NOTFOUND == hr) // if not set, use the current directory as the layout directory.
+    {
+        hr = VariableGetString(pVariables, BURN_BUNDLE_SOURCE_PROCESS_FOLDER, &sczLayoutDirectory);
+        if (E_NOTFOUND == hr) // if not set, use the current directory as the layout directory.
+        {
+            hr = PathForCurrentProcess(&sczExecutablePath, NULL);
+            ExitOnFailure(hr, "Failed to get path for current executing process as layout directory.");
+
+            hr = PathGetDirectory(sczExecutablePath, &sczLayoutDirectory);
+            ExitOnFailure(hr, "Failed to get executing process as layout directory.");
+        }
+    }
+    ExitOnFailure(hr, "Failed to get bundle layout directory property.");
+
+    hr = PathBackslashTerminate(&sczLayoutDirectory);
+    ExitOnFailure(hr, "Failed to ensure layout directory is backslash terminated.");
+
+    // Plan the layout of the bundle engine itself.
+    hr = AppendCacheAction(pPlan, &pCacheAction);
+    ExitOnFailure(hr, "Failed to append bundle start action.");
+
+    pCacheAction->type = BURN_CACHE_ACTION_TYPE_LAYOUT_BUNDLE;
+
+    hr = StrAllocString(&pCacheAction->bundleLayout.sczExecutableName, wzExecutableName, 0);
+    ExitOnFailure(hr, "Failed to to copy executable name for bundle.");
+
+    hr = StrAllocString(&pCacheAction->bundleLayout.sczLayoutDirectory, sczLayoutDirectory, 0);
+    ExitOnFailure(hr, "Failed to to copy layout directory for bundle.");
+
+    hr = CacheCalculateBundleLayoutWorkingPath(pPlan->wzBundleId, &pCacheAction->bundleLayout.sczUnverifiedPath);
+    ExitOnFailure(hr, "Failed to calculate bundle layout working path.");
+
+    pCacheAction->bundleLayout.qwBundleSize = qwBundleSize;
+
+    pPlan->qwCacheSizeTotal += qwBundleSize;
+
+    ++pPlan->cOverallProgressTicksTotal;
+
+    // Plan the layout of layout-only payloads.
+    for (DWORD i = 0; i < pPayloads->cPayloads; ++i)
+    {
+        BURN_PAYLOAD* pPayload = pPayloads->rgPayloads + i;
+        if (pPayload->fLayoutOnly)
+        {
+            // TODO: determine if a payload already exists in the layout and pass appropriate value fPayloadCached
+            // (instead of always FALSE).
+            hr = AppendCacheOrLayoutPayloadAction(pPlan, NULL, BURN_PLAN_INVALID_ACTION_INDEX, pPayload, FALSE, sczLayoutDirectory);
+            ExitOnFailure(hr, "Failed to plan layout payload.");
+        }
+    }
+
+    *psczLayoutDirectory = sczLayoutDirectory;
+    sczLayoutDirectory = NULL;
+
+LExit:
+    ReleaseStr(sczLayoutDirectory);
+    ReleaseStr(sczExecutablePath);
+
+    return hr;
+}
+
+extern "C" HRESULT PlanPackages(
+    __in BURN_REGISTRATION* pRegistration,
+    __in BURN_USER_EXPERIENCE* pUX,
+    __in BURN_PACKAGES* pPackages,
+    __in BURN_PLAN* pPlan,
+    __in BURN_LOGGING* pLog,
+    __in BURN_VARIABLES* pVariables,
+    __in BOOL fBundleInstalled,
+    __in BOOTSTRAPPER_DISPLAY display,
+    __in BOOTSTRAPPER_RELATION_TYPE relationType,
+    __in_z_opt LPCWSTR wzLayoutDirectory,
+    __inout HANDLE* phSyncpointEvent
+    )
+{
+    HRESULT hr = S_OK;
+    BOOL fBundlePerMachine = pPlan->fPerMachine; // bundle is per-machine if plan starts per-machine.
+    BURN_ROLLBACK_BOUNDARY* pRollbackBoundary = NULL;
+
+    PLAN_NONPERMANENT_PACKAGE_INDICES nonpermanentPackageIndices;
+    nonpermanentPackageIndices.iAfterExecuteFirstNonPermanentPackage = BURN_PLAN_INVALID_ACTION_INDEX;
+    nonpermanentPackageIndices.iBeforeRollbackFirstNonPermanentPackage = BURN_PLAN_INVALID_ACTION_INDEX;
+    nonpermanentPackageIndices.iAfterExecuteLastNonPermanentPackage = BURN_PLAN_INVALID_ACTION_INDEX;
+    nonpermanentPackageIndices.iAfterRollbackLastNonPermanentPackage = BURN_PLAN_INVALID_ACTION_INDEX;
+
+    // Plan the packages.
+    for (DWORD i = 0; i < pPackages->cPackages; ++i)
+    {
+        DWORD iPackage = (BOOTSTRAPPER_ACTION_UNINSTALL == pPlan->action) ? pPackages->cPackages - 1 - i : i;
+        BURN_PACKAGE* pPackage = pPackages->rgPackages + iPackage;
+
+        // Support passing Ancestors to embedded burn bundles
+        if (BURN_PACKAGE_TYPE_EXE == pPackage->type && BURN_EXE_PROTOCOL_TYPE_BURN == pPackage->Exe.protocol)
+        {
+            // Pass along any ancestors and ourself to prevent infinite loops.
+            if (pRegistration->sczAncestors && *pRegistration->sczAncestors)
+            {
+                hr = StrAllocFormatted(&pPackage->Exe.sczAncestors, L"%ls;%ls", pRegistration->sczAncestors, pRegistration->sczId);
+                ExitOnFailure(hr, "Failed to copy ancestors and self to related bundle ancestors.");
+            }
+            else
+            {
+                hr = StrAllocString(&pPackage->Exe.sczAncestors, pRegistration->sczId, 0);
+                ExitOnFailure(hr, "Failed to copy self to related bundle ancestors.");
+            }
+        }
+
+        hr = ProcessPackage(fBundlePerMachine, NULL, pUX, pPlan, pPackage, pLog, pVariables, display, relationType, wzLayoutDirectory, phSyncpointEvent, &pRollbackBoundary, &nonpermanentPackageIndices);
+        ExitOnFailure(hr, "Failed to process package.");
+
+        // Attempt to remove orphaned packages during uninstall. Currently only MSI packages are supported and should not require source.
+        if (BOOTSTRAPPER_ACTION_UNINSTALL == pPlan->action && BURN_PACKAGE_TYPE_MSI == pPackage->type && pPackage->Msi.fCompatibleInstalled)
+        {
+            BURN_PACKAGE* pCompatiblePackage = NULL;
+            BURN_EXECUTE_ACTION* pAction = NULL;
+
+            // Add the compatible package to the list.
+            hr = MsiEngineAddCompatiblePackage(pPackages, pPackage, &pCompatiblePackage);
+            ExitOnFailure(hr, "Failed to add compatible package for package: %ls", pPackage->sczId);
+
+            // Plan to load the compatible package into the elevated engine before its needed.
+            hr = PlanAppendExecuteAction(pPlan, &pAction);
+            ExitOnFailure(hr, "Failed to append execute action.");
+
+            pAction->type = BURN_EXECUTE_ACTION_TYPE_COMPATIBLE_PACKAGE;
+            pAction->compatiblePackage.pReferencePackage = pPackage;
+            pAction->compatiblePackage.qwInstalledVersion = pCompatiblePackage->Msi.qwVersion;
+
+            hr = StrAllocString(&pAction->compatiblePackage.sczInstalledProductCode, pCompatiblePackage->Msi.sczProductCode, 0);
+            ExitOnFailure(hr, "Failed to copy installed ProductCode");
+
+            // Process the compatible MSI package like any other.
+            hr = ProcessPackage(fBundlePerMachine, pPackage, pUX, pPlan, pCompatiblePackage, pLog, pVariables, display, relationType, wzLayoutDirectory, phSyncpointEvent, &pRollbackBoundary, &nonpermanentPackageIndices);
+            ExitOnFailure(hr, "Failed to process compatible package.");
+
+            if (BOOTSTRAPPER_ACTION_STATE_UNINSTALL == pCompatiblePackage->execute)
+            {
+                LogId(REPORT_STANDARD, MSG_PLANNED_ORPHAN_PACKAGE_FROM_PROVIDER, pPackage->sczId, pCompatiblePackage->Msi.sczProductCode, pPackage->Msi.sczProductCode);
+            }
+        }
+    }
+
+    // Insert the "keep registration" and "remove registration" actions in the plan when installing the first time and anytime we are uninstalling respectively.
+    if (!fBundleInstalled && (BOOTSTRAPPER_ACTION_INSTALL == pPlan->action || BOOTSTRAPPER_ACTION_MODIFY == pPlan->action || BOOTSTRAPPER_ACTION_REPAIR == pPlan->action))
+    {
+        if (BURN_PLAN_INVALID_ACTION_INDEX == nonpermanentPackageIndices.iAfterExecuteFirstNonPermanentPackage)
+        {
+            nonpermanentPackageIndices.iAfterExecuteFirstNonPermanentPackage = pPlan->cExecuteActions;
+            nonpermanentPackageIndices.iBeforeRollbackFirstNonPermanentPackage = pPlan->cRollbackActions;
+        }
+
+        hr = PlanKeepRegistration(pPlan, nonpermanentPackageIndices.iAfterExecuteFirstNonPermanentPackage, nonpermanentPackageIndices.iBeforeRollbackFirstNonPermanentPackage);
+        ExitOnFailure(hr, "Failed to plan install keep registration.");
+    }
+    else if (BOOTSTRAPPER_ACTION_UNINSTALL == pPlan->action)
+    {
+        if (BURN_PLAN_INVALID_ACTION_INDEX == nonpermanentPackageIndices.iAfterExecuteLastNonPermanentPackage)
+        {
+            nonpermanentPackageIndices.iAfterExecuteLastNonPermanentPackage = pPlan->cExecuteActions;
+            nonpermanentPackageIndices.iAfterRollbackLastNonPermanentPackage = pPlan->cRollbackActions;
+        }
+
+        hr = PlanRemoveRegistration(pPlan, nonpermanentPackageIndices.iAfterExecuteLastNonPermanentPackage, nonpermanentPackageIndices.iAfterRollbackLastNonPermanentPackage);
+        ExitOnFailure(hr, "Failed to plan uninstall remove registration.");
+    }
+
+    // If we still have an open rollback boundary, complete it.
+    if (pRollbackBoundary)
+    {
+        hr = PlanRollbackBoundaryComplete(pPlan);
+        ExitOnFailure(hr, "Failed to plan rollback boundary begin.");
+
+        pRollbackBoundary = NULL;
+    }
+
+    // Plan clean up of packages.
+    for (DWORD i = 0; i < pPackages->cPackages; ++i)
+    {
+        DWORD iPackage = (BOOTSTRAPPER_ACTION_UNINSTALL == pPlan->action) ? pPackages->cPackages - 1 - i : i;
+        BURN_PACKAGE* pPackage = pPackages->rgPackages + iPackage;
+
+        hr = PlanCleanPackage(pPlan, pPackage);
+        ExitOnFailure(hr, "Failed to plan clean package.");
+    }
+
+    // Plan best-effort clean up of compatible packages.
+    for (DWORD i = 0; i < pPackages->cCompatiblePackages; ++i)
+    {
+        DWORD iPackage = (BOOTSTRAPPER_ACTION_UNINSTALL == pPlan->action) ? pPackages->cCompatiblePackages - 1 - i : i;
+        BURN_PACKAGE* pCompatiblePackage = pPackages->rgCompatiblePackages + iPackage;
+
+        PlanCleanPackage(pPlan, pCompatiblePackage);
+    }
+
+LExit:
+    return hr;
+}
+
+extern "C" HRESULT PlanRegistration(
+    __in BURN_PLAN* pPlan,
+    __in BURN_REGISTRATION* pRegistration,
+    __in BOOTSTRAPPER_RESUME_TYPE resumeType,
+    __in BOOTSTRAPPER_RELATION_TYPE relationType,
+    __in_z_opt LPCWSTR wzIgnoreDependencies,
+    __out BOOL* pfContinuePlanning
+    )
+{
+    HRESULT hr = S_OK;
+    LPCWSTR wzSelfDependent = NULL;
+    STRINGDICT_HANDLE sdIgnoreDependents = NULL;
+    DEPENDENCY* rgDependencies = NULL;
+    UINT cDependencies = 0;
+
+    pPlan->fRegister = TRUE; // register the bundle since we're modifying machine state.
+
+    // Keep the registration if the bundle was already installed or we are planning after a restart.
+    pPlan->fKeepRegistrationDefault = (pRegistration->fInstalled || BOOTSTRAPPER_RESUME_TYPE_REBOOT == resumeType);
+
+    pPlan->fDisallowRemoval = FALSE; // by default the bundle can be planned to be removed
+
+    // If no parent was specified at all, use the bundle id as the self dependent.
+    if (!pRegistration->sczActiveParent)
+    {
+        wzSelfDependent = pRegistration->sczId;
+    }
+    else if (*pRegistration->sczActiveParent) // if parent was specified use that as the self dependent.
+    {
+        wzSelfDependent = pRegistration->sczActiveParent;
+    }
+    // else parent:none was used which means we should not register a dependency on ourself.
+
+    if (BOOTSTRAPPER_ACTION_UNINSTALL == pPlan->action)
+    {
+        // If our provider key was detected and it points to our current bundle then we can
+        // unregister the bundle dependency.
+        if (pRegistration->sczDetectedProviderKeyBundleId &&
+            CSTR_EQUAL == ::CompareStringW(LOCALE_NEUTRAL, NORM_IGNORECASE, pRegistration->sczId, -1, pRegistration->sczDetectedProviderKeyBundleId, -1))
+        {
+            pPlan->dependencyRegistrationAction = BURN_DEPENDENCY_REGISTRATION_ACTION_UNREGISTER;
+        }
+        else // log that another bundle already owned our registration, hopefully this only happens when a newer version
+        {    // of a bundle installed and is in the process of upgrading us.
+            LogId(REPORT_STANDARD, MSG_PLAN_SKIPPED_PROVIDER_KEY_REMOVAL, pRegistration->sczProviderKey, pRegistration->sczDetectedProviderKeyBundleId);
+        }
+
+        // Create the dictionary of dependents that should be ignored.
+        hr = DictCreateStringList(&sdIgnoreDependents, 5, DICT_FLAG_CASEINSENSITIVE);
+        ExitOnFailure(hr, "Failed to create the string dictionary.");
+
+        // If the self-dependent dependent exists, plan its removal. If we did not do this, we
+        // would prevent self-removal.
+        if (wzSelfDependent && DependencyDependentExists(pRegistration, wzSelfDependent))
+        {
+            hr = AddRegistrationAction(pPlan, BURN_DEPENDENT_REGISTRATION_ACTION_TYPE_UNREGISTER, wzSelfDependent, pRegistration->sczId);
+            ExitOnFailure(hr, "Failed to allocate registration action.");
+
+            hr = DependencyAddIgnoreDependencies(sdIgnoreDependents, wzSelfDependent);
+            ExitOnFailure(hr, "Failed to add self-dependent to ignore dependents.");
+        }
+
+        // If we are not doing an upgrade, we check to see if there are still dependents on us and if so we skip planning.
+        // However, when being upgraded, we always execute our uninstall because a newer version of us is probably
+        // already on the machine and we need to clean up the stuff specific to this bundle.
+        if (BOOTSTRAPPER_RELATION_UPGRADE != relationType)
+        {
+            // If there were other dependencies to ignore, add them.
+            if (wzIgnoreDependencies && *wzIgnoreDependencies)
+            {
+                hr = DependencyAddIgnoreDependencies(sdIgnoreDependents, wzIgnoreDependencies);
+                ExitOnFailure(hr, "Failed to add dependents ignored from command-line.");
+            }
+
+            // For addon or patch bundles, dependent related bundles should be ignored. This allows
+            // that addon or patch to be removed even though bundles it targets still are registered.
+            for (DWORD i = 0; i < pRegistration->relatedBundles.cRelatedBundles; ++i)
+            {
+                const BURN_RELATED_BUNDLE* pRelatedBundle = pRegistration->relatedBundles.rgRelatedBundles + i;
+
+                if (BOOTSTRAPPER_RELATION_DEPENDENT == pRelatedBundle->relationType)
+                {
+                    for (DWORD j = 0; j < pRelatedBundle->package.cDependencyProviders; ++j)
+                    {
+                        const BURN_DEPENDENCY_PROVIDER* pProvider = pRelatedBundle->package.rgDependencyProviders + j;
+
+                        hr = DependencyAddIgnoreDependencies(sdIgnoreDependents, pProvider->sczKey);
+                        ExitOnFailure(hr, "Failed to add dependent bundle provider key to ignore dependents.");
+                    }
+                }
+            }
+
+            // If there are any (non-ignored and not-planned-to-be-removed) dependents left, uninstall.
+            hr = DepCheckDependents(pRegistration->hkRoot, pRegistration->sczProviderKey, 0, sdIgnoreDependents, &rgDependencies, &cDependencies);
+            if (E_FILENOTFOUND == hr)
+            {
+                hr = S_OK;
+            }
+            else if (SUCCEEDED(hr) && cDependencies)
+            {
+                // TODO: callback to the BA and let it have the option to ignore any of these dependents?
+
+                 pPlan->fDisallowRemoval = TRUE; // ensure the registration stays
+                 *pfContinuePlanning = FALSE; // skip the rest of planning.
+
+                 LogId(REPORT_STANDARD, MSG_PLAN_SKIPPED_DUE_TO_DEPENDENTS, cDependencies);
+            }
+            ExitOnFailure(hr, "Failed to check for remaining dependents during planning.");
+        }
+    }
+    else
+    {
+        BOOL fAddonOrPatchBundle = (pRegistration->cAddonCodes || pRegistration->cPatchCodes);
+
+        // If the bundle is not cached or will not be cached after restart, ensure the bundle is cached.
+        if (!FileExistsAfterRestart(pRegistration->sczCacheExecutablePath, NULL))
+        {
+            pPlan->dwRegistrationOperations |= BURN_REGISTRATION_ACTION_OPERATIONS_CACHE_BUNDLE;
+            pPlan->dwRegistrationOperations |= BURN_REGISTRATION_ACTION_OPERATIONS_WRITE_REGISTRATION;
+        }
+        else if (BOOTSTRAPPER_ACTION_REPAIR == pPlan->action && !CacheBundleRunningFromCache()) // repairing but not not running from the cache.
+        {
+            pPlan->dwRegistrationOperations |= BURN_REGISTRATION_ACTION_OPERATIONS_CACHE_BUNDLE;
+            pPlan->dwRegistrationOperations |= BURN_REGISTRATION_ACTION_OPERATIONS_WRITE_REGISTRATION;
+        }
+        else if (BOOTSTRAPPER_ACTION_REPAIR == pPlan->action) // just repair, make sure the registration is "fixed up".
+        {
+            pPlan->dwRegistrationOperations |= BURN_REGISTRATION_ACTION_OPERATIONS_WRITE_REGISTRATION;
+        }
+
+        // Always update our estimated size registration when installing/modify/repair since things
+        // may have been added or removed or it just needs to be "fixed up".
+        pPlan->dwRegistrationOperations |= BURN_REGISTRATION_ACTION_OPERATIONS_UPDATE_SIZE;
+
+        // Always plan to write our provider key registration when installing/modify/repair to "fix it"
+        // if broken.
+        pPlan->dependencyRegistrationAction = BURN_DEPENDENCY_REGISTRATION_ACTION_REGISTER;
+
+        // Register each dependent related bundle. The ensures that addons and patches are reference
+        // counted and stick around until the last targeted bundle is removed.
+        for (DWORD i = 0; i < pRegistration->relatedBundles.cRelatedBundles; ++i)
+        {
+            const BURN_RELATED_BUNDLE* pRelatedBundle = pRegistration->relatedBundles.rgRelatedBundles + i;
+
+            if (BOOTSTRAPPER_RELATION_DEPENDENT == pRelatedBundle->relationType)
+            {
+                for (DWORD j = 0; j < pRelatedBundle->package.cDependencyProviders; ++j)
+                {
+                    const BURN_DEPENDENCY_PROVIDER* pProvider = pRelatedBundle->package.rgDependencyProviders + j;
+
+                    if (!DependencyDependentExists(pRegistration, pProvider->sczKey))
+                    {
+                        hr = AddRegistrationAction(pPlan, BURN_DEPENDENT_REGISTRATION_ACTION_TYPE_REGISTER, pProvider->sczKey, pRelatedBundle->package.sczId);
+                        ExitOnFailure(hr, "Failed to add registration action for dependent related bundle.");
+                    }
+                }
+            }
+        }
+
+        // Only do the following if we decided there was a dependent self to register. If so and and an explicit parent was
+        // provided, register dependent self. Otherwise, if this bundle is not an addon or patch bundle then self-regisiter
+        // as our own dependent.
+        if (wzSelfDependent && (pRegistration->sczActiveParent || !fAddonOrPatchBundle))
+        {
+            if (!DependencyDependentExists(pRegistration, wzSelfDependent))
+            {
+                hr = AddRegistrationAction(pPlan, BURN_DEPENDENT_REGISTRATION_ACTION_TYPE_REGISTER, wzSelfDependent, pRegistration->sczId);
+                ExitOnFailure(hr, "Failed to add registration action for self dependent.");
+            }
+        }
+    }
+
+LExit:
+    ReleaseDict(sdIgnoreDependents);
+    ReleaseDependencyArray(rgDependencies, cDependencies);
+
+    return hr;
+}
+
+extern "C" HRESULT PlanPassThroughBundle(
+    __in BURN_USER_EXPERIENCE* pUX,
+    __in BURN_PACKAGE* pPackage,
+    __in BURN_PLAN* pPlan,
+    __in BURN_LOGGING* pLog,
+    __in BURN_VARIABLES* pVariables,
+    __in BOOTSTRAPPER_DISPLAY display,
+    __in BOOTSTRAPPER_RELATION_TYPE relationType,
+    __inout HANDLE* phSyncpointEvent
+    )
+{
+    HRESULT hr = S_OK;
+    BOOL fBundlePerMachine = pPlan->fPerMachine; // bundle is per-machine if plan starts per-machine.
+    BURN_ROLLBACK_BOUNDARY* pRollbackBoundary = NULL;
+
+    // Plan passthrough package.
+    hr = ProcessPackage(fBundlePerMachine, NULL, pUX, pPlan, pPackage, pLog, pVariables, display, relationType, NULL, phSyncpointEvent, &pRollbackBoundary, NULL);
+    ExitOnFailure(hr, "Failed to process passthrough package.");
+
+    // If we still have an open rollback boundary, complete it.
+    if (pRollbackBoundary)
+    {
+        hr = PlanRollbackBoundaryComplete(pPlan);
+        ExitOnFailure(hr, "Failed to plan rollback boundary for passthrough package.");
+    }
+
+    // Notice that the PlanCleanPackage() function is purposefully missing here. Passthrough packages
+    // are never cleaned up by the calling bundle (they delete themselves when appropriate) so we don't
+    // need to plan clean up.
+
+LExit:
+    return hr;
+}
+
+extern "C" HRESULT PlanUpdateBundle(
+    __in BURN_USER_EXPERIENCE* pUX,
+    __in BURN_PACKAGE* pPackage,
+    __in BURN_PLAN* pPlan,
+    __in BURN_LOGGING* pLog,
+    __in BURN_VARIABLES* pVariables,
+    __in BOOTSTRAPPER_DISPLAY display,
+    __in BOOTSTRAPPER_RELATION_TYPE relationType,
+    __inout HANDLE* phSyncpointEvent
+    )
+{
+    HRESULT hr = S_OK;
+    BOOL fBundlePerMachine = pPlan->fPerMachine; // bundle is per-machine if plan starts per-machine.
+    BURN_ROLLBACK_BOUNDARY* pRollbackBoundary = NULL;
+
+    // Plan update package.
+    hr = ProcessPackage(fBundlePerMachine, NULL, pUX, pPlan, pPackage, pLog, pVariables, display, relationType, NULL, phSyncpointEvent, &pRollbackBoundary, NULL);
+    ExitOnFailure(hr, "Failed to process update package.");
+
+    // If we still have an open rollback boundary, complete it.
+    if (pRollbackBoundary)
+    {
+        hr = PlanRollbackBoundaryComplete(pPlan);
+        ExitOnFailure(hr, "Failed to plan rollback boundary for update package.");
+    }
+
+    // Plan clean up of update package.
+    hr = PlanCleanPackage(pPlan, pPackage);
+    ExitOnFailure(hr, "Failed to plan clean of update package.");
+
+LExit:
+    return hr;
+}
+
+static HRESULT ProcessPackage(
+    __in BOOL fBundlePerMachine,
+    __in BURN_PACKAGE* pCompatiblePackageParent,
+    __in BURN_USER_EXPERIENCE* pUX,
+    __in BURN_PLAN* pPlan,
+    __in BURN_PACKAGE* pPackage,
+    __in BURN_LOGGING* pLog,
+    __in BURN_VARIABLES* pVariables,
+    __in BOOTSTRAPPER_DISPLAY display,
+    __in BOOTSTRAPPER_RELATION_TYPE relationType,
+    __in_z_opt LPCWSTR wzLayoutDirectory,
+    __inout HANDLE* phSyncpointEvent,
+    __inout BURN_ROLLBACK_BOUNDARY** ppRollbackBoundary,
+    __in_opt PLAN_NONPERMANENT_PACKAGE_INDICES* pNonpermanentPackageIndices
+    )
+{
+    HRESULT hr = S_OK;
+    BURN_ROLLBACK_BOUNDARY* pEffectiveRollbackBoundary = NULL;
+    BOOL fPlanPackageBegan = FALSE;
+
+    // Remember the default requested state so the engine doesn't get blamed for planning the wrong thing if the BA changes it.
+    hr = PlanDefaultPackageRequestState(pPackage->type, pPackage->currentState, !pPackage->fUninstallable, pPlan->action, pVariables, pPackage->sczInstallCondition, relationType, &pPackage->defaultRequested);
+    ExitOnFailure(hr, "Failed to set default package state.");
+
+    pPackage->requested = pPackage->defaultRequested;
+    fPlanPackageBegan = TRUE;
+
+    if (pCompatiblePackageParent)
+    {
+        AssertSz(BURN_PACKAGE_TYPE_MSI == pPackage->type, "Currently only MSI packages have compatible packages.");
+
+        hr = UserExperienceOnPlanCompatibleMsiPackageBegin(pUX, pCompatiblePackageParent->sczId, pPackage->sczId, pPackage->Msi.qwVersion, &pPackage->requested);
+        ExitOnRootFailure(hr, "BA aborted plan compatible MSI package begin.");
+    }
+    else
+    {
+        hr = UserExperienceOnPlanPackageBegin(pUX, pPackage->sczId, &pPackage->requested);
+        ExitOnRootFailure(hr, "BA aborted plan package begin.");
+    }
+
+    pEffectiveRollbackBoundary = (BOOTSTRAPPER_ACTION_UNINSTALL == pPlan->action) ? pPackage->pRollbackBoundaryBackward : pPackage->pRollbackBoundaryForward;
+    hr = ProcessPackageRollbackBoundary(pPlan, pEffectiveRollbackBoundary, ppRollbackBoundary);
+    ExitOnFailure(hr, "Failed to process package rollback boundary.");
+
+    // If the package is in a requested state, plan it.
+    if (BOOTSTRAPPER_REQUEST_STATE_NONE != pPackage->requested)
+    {
+        if (BOOTSTRAPPER_ACTION_LAYOUT == pPlan->action)
+        {
+            hr = PlanLayoutPackage(pPlan, pPackage, wzLayoutDirectory);
+            ExitOnFailure(hr, "Failed to plan layout package.");
+        }
+        else
+        {
+            if (pPackage->fUninstallable && pNonpermanentPackageIndices)
+            {
+                if (BURN_PLAN_INVALID_ACTION_INDEX == pNonpermanentPackageIndices->iBeforeRollbackFirstNonPermanentPackage)
+                {
+                    pNonpermanentPackageIndices->iBeforeRollbackFirstNonPermanentPackage = pPlan->cRollbackActions;
+                }
+            }
+
+            hr = PlanExecutePackage(fBundlePerMachine, display, pUX, pPlan, pPackage, pLog, pVariables, phSyncpointEvent);
+            ExitOnFailure(hr, "Failed to plan execute package.");
+
+            if (pPackage->fUninstallable && pNonpermanentPackageIndices)
+            {
+                if (BURN_PLAN_INVALID_ACTION_INDEX == pNonpermanentPackageIndices->iAfterExecuteFirstNonPermanentPackage)
+                {
+                    pNonpermanentPackageIndices->iAfterExecuteFirstNonPermanentPackage = pPlan->cExecuteActions - 1;
+                }
+
+                pNonpermanentPackageIndices->iAfterExecuteLastNonPermanentPackage = pPlan->cExecuteActions;
+                pNonpermanentPackageIndices->iAfterRollbackLastNonPermanentPackage = pPlan->cRollbackActions;
+            }
+        }
+    }
+    else if (BOOTSTRAPPER_ACTION_LAYOUT != pPlan->action)
+    {
+        // All packages that have cacheType set to always should be cached if the bundle is going to be present.
+        if (BURN_CACHE_TYPE_ALWAYS == pPackage->cacheType && BOOTSTRAPPER_ACTION_INSTALL <= pPlan->action)
+        {
+            hr = PlanCachePackage(fBundlePerMachine, pUX, pPlan, pPackage, pVariables, phSyncpointEvent);
+            ExitOnFailure(hr, "Failed to plan cache package.");
+        }
+        else
+        {
+            // Make sure the package is properly ref-counted even if no plan is requested.
+            hr = PlanDependencyActions(fBundlePerMachine, pPlan, pPackage);
+            ExitOnFailure(hr, "Failed to plan dependency actions for package: %ls", pPackage->sczId);
+        }
+    }
+
+    // Add the checkpoint after each package and dependency registration action.
+    if (BOOTSTRAPPER_ACTION_STATE_NONE != pPackage->execute || BOOTSTRAPPER_ACTION_STATE_NONE != pPackage->rollback || BURN_DEPENDENCY_ACTION_NONE != pPackage->dependencyExecute)
+    {
+        hr = PlanExecuteCheckpoint(pPlan);
+        ExitOnFailure(hr, "Failed to append execute checkpoint.");
+    }
+
+LExit:
+    if (fPlanPackageBegan)
+    {
+        if (pCompatiblePackageParent)
+        {
+            UserExperienceOnPlanCompatibleMsiPackageComplete(pUX, pCompatiblePackageParent->sczId, pPackage->sczId, hr, pPackage->currentState, pPackage->requested, pPackage->execute, pPackage->rollback);
+        }
+        else
+        {
+            UserExperienceOnPlanPackageComplete(pUX, pPackage->sczId, hr, pPackage->currentState, pPackage->requested, pPackage->execute, pPackage->rollback);
+        }
+    }
+
+    return hr;
+}
+
+static HRESULT ProcessPackageRollbackBoundary(
+    __in BURN_PLAN* pPlan,
+    __in_opt BURN_ROLLBACK_BOUNDARY* pEffectiveRollbackBoundary,
+    __inout BURN_ROLLBACK_BOUNDARY** ppRollbackBoundary
+    )
+{
+    HRESULT hr = S_OK;
+
+    // If the package marks the start of a rollback boundary, start a new one.
+    if (pEffectiveRollbackBoundary)
+    {
+        // Complete previous rollback boundary.
+        if (*ppRollbackBoundary)
+        {
+            hr = PlanRollbackBoundaryComplete(pPlan);
+            ExitOnFailure(hr, "Failed to plan rollback boundary complete.");
+        }
+
+        // Start new rollback boundary.
+        hr = PlanRollbackBoundaryBegin(pPlan, pEffectiveRollbackBoundary);
+        ExitOnFailure(hr, "Failed to plan rollback boundary begin.");
+
+        *ppRollbackBoundary = pEffectiveRollbackBoundary;
+    }
+
+LExit:
+    return hr;
+}
+
+extern "C" HRESULT PlanLayoutPackage(
+    __in BURN_PLAN* pPlan,
+    __in BURN_PACKAGE* pPackage,
+    __in_z_opt LPCWSTR wzLayoutDirectory
+    )
+{
+    HRESULT hr = S_OK;
+    BURN_CACHE_ACTION* pCacheAction = NULL;
+    DWORD iPackageStartAction = 0;
+
+    hr = AppendCacheAction(pPlan, &pCacheAction);
+    ExitOnFailure(hr, "Failed to append package start action.");
+
+    pCacheAction->type = BURN_CACHE_ACTION_TYPE_PACKAGE_START;
+    pCacheAction->packageStart.pPackage = pPackage;
+
+    // Remember the index for the package start action (which is now the last in the cache
+    // actions array) because the array may be resized later and move around in memory.
+    iPackageStartAction = pPlan->cCacheActions - 1;
+
+    // If any of the package payloads are not cached, add them to the plan.
+    for (DWORD i = 0; i < pPackage->cPayloads; ++i)
+    {
+        BURN_PACKAGE_PAYLOAD* pPackagePayload = &pPackage->rgPayloads[i];
+
+        // If doing layout and the package is in a container.
+        if (wzLayoutDirectory && pPackagePayload->pPayload->pContainer)
+        {
+            // TODO: determine if a container already exists in the layout and pass appropriate value fPayloadCached (instead of always FALSE).
+            hr = AppendLayoutContainerAction(pPlan, pPackage, iPackageStartAction, pPackagePayload->pPayload->pContainer, FALSE, wzLayoutDirectory);
+            ExitOnFailure(hr, "Failed to append layout container action.");
+        }
+        else
+        {
+            // TODO: determine if a payload already exists in the layout and pass appropriate value fPayloadCached (instead of always FALSE).
+            hr = AppendCacheOrLayoutPayloadAction(pPlan, pPackage, iPackageStartAction, pPackagePayload->pPayload, FALSE, wzLayoutDirectory);
+            ExitOnFailure(hr, "Failed to append cache/layout payload action.");
+        }
+
+        Assert(BURN_CACHE_ACTION_TYPE_PACKAGE_START == pPlan->rgCacheActions[iPackageStartAction].type);
+        ++pPlan->rgCacheActions[iPackageStartAction].packageStart.cCachePayloads;
+        pPlan->rgCacheActions[iPackageStartAction].packageStart.qwCachePayloadSizeTotal += pPackagePayload->pPayload->qwFileSize;
+    }
+
+    // Create package stop action.
+    hr = AppendCacheAction(pPlan, &pCacheAction);
+    ExitOnFailure(hr, "Failed to append cache action.");
+
+    pCacheAction->type = BURN_CACHE_ACTION_TYPE_PACKAGE_STOP;
+    pCacheAction->packageStop.pPackage = pPackage;
+
+    // Update the start action with the location of the complete action.
+    pPlan->rgCacheActions[iPackageStartAction].packageStart.iPackageCompleteAction = pPlan->cCacheActions - 1;
+
+    ++pPlan->cOverallProgressTicksTotal;
+
+LExit:
+    return hr;
+}
+
+extern "C" HRESULT PlanCachePackage(
+    __in BOOL fPerMachine,
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in BURN_PLAN* pPlan,
+    __in BURN_PACKAGE* pPackage,
+    __in BURN_VARIABLES* pVariables,
+    __out HANDLE* phSyncpointEvent
+    )
+{
+    HRESULT hr = S_OK;
+    BOOL fBARequestedCache = FALSE;
+
+    // Calculate the execute actions because we need them to decide whether the package should be cached.
+    hr = CalculateExecuteActions(pUserExperience, pPackage, pVariables, &fBARequestedCache);
+    ExitOnFailure(hr, "Failed to calculate execute actions for package: %ls", pPackage->sczId);
+
+    if (fBARequestedCache || NeedsCache(pPlan, pPackage))
+    {
+        hr = AddCachePackage(pPlan, pPackage, phSyncpointEvent);
+        ExitOnFailure(hr, "Failed to plan cache package.");
+
+        if (pPackage->fPerMachine)
+        {
+            pPlan->fPerMachine = TRUE;
+        }
+    }
+
+    // Make sure the package is properly ref-counted.
+    hr = PlanDependencyActions(fPerMachine, pPlan, pPackage);
+    ExitOnFailure(hr, "Failed to plan dependency actions for package: %ls", pPackage->sczId);
+
+LExit:
+    return hr;
+}
+
+extern "C" HRESULT PlanExecutePackage(
+    __in BOOL fPerMachine,
+    __in BOOTSTRAPPER_DISPLAY display,
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in BURN_PLAN* pPlan,
+    __in BURN_PACKAGE* pPackage,
+    __in BURN_LOGGING* pLog,
+    __in BURN_VARIABLES* pVariables,
+    __inout HANDLE* phSyncpointEvent
+    )
+{
+    HRESULT hr = S_OK;
+    BOOL fBARequestedCache = FALSE;
+
+    hr = CalculateExecuteActions(pUserExperience, pPackage, pVariables, &fBARequestedCache);
+    ExitOnFailure(hr, "Failed to calculate plan actions for package: %ls", pPackage->sczId);
+
+    // Calculate package states based on reference count and plan certain dependency actions prior to planning the package execute action.
+    hr = DependencyPlanPackageBegin(fPerMachine, pPackage, pPlan);
+    ExitOnFailure(hr, "Failed to begin plan dependency actions for package: %ls", pPackage->sczId);
+
+    if (fBARequestedCache || NeedsCache(pPlan, pPackage))
+    {
+        hr = AddCachePackage(pPlan, pPackage, phSyncpointEvent);
+        ExitOnFailure(hr, "Failed to plan cache package.");
+    }
+    else if (BURN_CACHE_STATE_COMPLETE != pPackage->cache && // if the package is not in the cache, disable any rollback that would require the package from the cache.
+             (BOOTSTRAPPER_ACTION_STATE_UNINSTALL < pPackage->rollback || (BURN_PACKAGE_TYPE_EXE == pPackage->type && BOOTSTRAPPER_ACTION_STATE_NONE != pPackage->rollback))
+            )
+    {
+        LogId(REPORT_STANDARD, MSG_PLAN_DISABLING_ROLLBACK_NO_CACHE, pPackage->sczId, LoggingCacheStateToString(pPackage->cache), LoggingActionStateToString(pPackage->rollback));
+        pPackage->rollback = BOOTSTRAPPER_ACTION_STATE_NONE;
+    }
+
+    // Add the cache and install size to estimated size if it will be on the machine at the end of the install
+    if (BOOTSTRAPPER_REQUEST_STATE_PRESENT == pPackage->requested ||
+        (BOOTSTRAPPER_PACKAGE_STATE_PRESENT == pPackage->currentState && BOOTSTRAPPER_REQUEST_STATE_ABSENT < pPackage->requested) ||
+        BURN_CACHE_TYPE_ALWAYS == pPackage->cacheType
+       )
+    {
+        // If the package will remain in the cache, add the package size to the estimated size
+        if (BURN_CACHE_TYPE_YES <= pPackage->cacheType)
+        {
+            pPlan->qwEstimatedSize += pPackage->qwSize;
+        }
+
+        // If the package will end up installed on the machine, add the install size to the estimated size.
+        if (BOOTSTRAPPER_REQUEST_STATE_CACHE < pPackage->requested)
+        {
+            // MSP packages get cached automatically by windows installer with any embedded cabs, so include that in the size as well
+            if (BURN_PACKAGE_TYPE_MSP == pPackage->type)
+            {
+                pPlan->qwEstimatedSize += pPackage->qwSize;
+            }
+
+            pPlan->qwEstimatedSize += pPackage->qwInstallSize;
+        }
+    }
+
+    // Add execute actions.
+    switch (pPackage->type)
+    {
+    case BURN_PACKAGE_TYPE_EXE:
+        hr = ExeEnginePlanAddPackage(NULL, pPackage, pPlan, pLog, pVariables, *phSyncpointEvent, pPackage->fAcquire);
+        break;
+
+    case BURN_PACKAGE_TYPE_MSI:
+        hr = MsiEnginePlanAddPackage(display, pPackage, pPlan, pLog, pVariables, *phSyncpointEvent, pPackage->fAcquire);
+        break;
+
+    case BURN_PACKAGE_TYPE_MSP:
+        hr = MspEnginePlanAddPackage(display, pPackage, pPlan, pLog, pVariables, *phSyncpointEvent, pPackage->fAcquire);
+        break;
+
+    case BURN_PACKAGE_TYPE_MSU:
+        hr = MsuEnginePlanAddPackage(pPackage, pPlan, pLog, pVariables, *phSyncpointEvent, pPackage->fAcquire);
+        break;
+
+    default:
+        hr = E_UNEXPECTED;
+        ExitOnFailure(hr, "Invalid package type.");
+    }
+    ExitOnFailure(hr, "Failed to add plan actions for package: %ls", pPackage->sczId);
+
+    // Plan certain dependency actions after planning the package execute action.
+    hr = DependencyPlanPackageComplete(pPackage, pPlan);
+    ExitOnFailure(hr, "Failed to complete plan dependency actions for package: %ls", pPackage->sczId);
+
+    // If we are going to take any action on this package, add progress for it.
+    if (BOOTSTRAPPER_ACTION_STATE_NONE != pPackage->execute || BOOTSTRAPPER_ACTION_STATE_NONE != pPackage->rollback)
+    {
+        LoggingIncrementPackageSequence();
+
+        ++pPlan->cExecutePackagesTotal;
+        ++pPlan->cOverallProgressTicksTotal;
+
+        // If package is per-machine and is being executed, flag the plan to be per-machine as well.
+        if (pPackage->fPerMachine)
+        {
+            pPlan->fPerMachine = TRUE;
+        }
+    }
+
+LExit:
+    return hr;
+}
+
+extern "C" HRESULT PlanRelatedBundlesBegin(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in BURN_REGISTRATION* pRegistration,
+    __in BOOTSTRAPPER_RELATION_TYPE relationType,
+    __in BURN_PLAN* pPlan
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR* rgsczAncestors = NULL;
+    UINT cAncestors = 0;
+    STRINGDICT_HANDLE sdAncestors = NULL;
+
+    if (pRegistration->sczAncestors)
+    {
+        hr = StrSplitAllocArray(&rgsczAncestors, &cAncestors, pRegistration->sczAncestors, L";");
+        ExitOnFailure(hr, "Failed to create string array from ancestors.");
+
+        hr = DictCreateStringListFromArray(&sdAncestors, rgsczAncestors, cAncestors, DICT_FLAG_CASEINSENSITIVE);
+        ExitOnFailure(hr, "Failed to create dictionary from ancestors array.");
+    }
+
+    for (DWORD i = 0; i < pRegistration->relatedBundles.cRelatedBundles; ++i)
+    {
+        BURN_RELATED_BUNDLE* pRelatedBundle = pRegistration->relatedBundles.rgRelatedBundles + i;
+        pRelatedBundle->package.defaultRequested = BOOTSTRAPPER_REQUEST_STATE_NONE;
+        pRelatedBundle->package.requested = BOOTSTRAPPER_REQUEST_STATE_NONE;
+
+        // Do not execute the same bundle twice.
+        if (sdAncestors)
+        {
+            hr = DictKeyExists(sdAncestors, pRelatedBundle->package.sczId);
+            if (SUCCEEDED(hr))
+            {
+                LogId(REPORT_STANDARD, MSG_PLAN_SKIPPED_RELATED_BUNDLE_SCHEDULED, pRelatedBundle->package.sczId, LoggingRelationTypeToString(pRelatedBundle->relationType));
+                continue;
+            }
+            else if (E_NOTFOUND != hr)
+            {
+                ExitOnFailure(hr, "Failed to lookup the bundle ID in the ancestors dictionary.");
+            }
+        }
+        else if (BOOTSTRAPPER_RELATION_DEPENDENT == pRelatedBundle->relationType && BOOTSTRAPPER_RELATION_NONE != relationType)
+        {
+            // Avoid repair loops for older bundles that do not handle ancestors.
+            LogId(REPORT_STANDARD, MSG_PLAN_SKIPPED_RELATED_BUNDLE_DEPENDENT, pRelatedBundle->package.sczId, LoggingRelationTypeToString(pRelatedBundle->relationType), LoggingRelationTypeToString(relationType));
+            continue;
+        }
+
+        // Pass along any ancestors and ourself to prevent infinite loops.
+        if (pRegistration->sczAncestors && *pRegistration->sczAncestors)
+        {
+            hr = StrAllocFormatted(&pRelatedBundle->package.Exe.sczAncestors, L"%ls;%ls", pRegistration->sczAncestors, pRegistration->sczId);
+            ExitOnFailure(hr, "Failed to copy ancestors and self to related bundle ancestors.");
+        }
+        else
+        {
+            hr = StrAllocString(&pRelatedBundle->package.Exe.sczAncestors, pRegistration->sczId, 0);
+            ExitOnFailure(hr, "Failed to copy self to related bundle ancestors.");
+        }
+
+        switch (pRelatedBundle->relationType)
+        {
+        case BOOTSTRAPPER_RELATION_UPGRADE:
+            if (BOOTSTRAPPER_RELATION_UPGRADE != relationType && BOOTSTRAPPER_ACTION_UNINSTALL < pPlan->action)
+            {
+                pRelatedBundle->package.requested = (pRegistration->qwVersion > pRelatedBundle->qwVersion) ? BOOTSTRAPPER_REQUEST_STATE_ABSENT : BOOTSTRAPPER_REQUEST_STATE_NONE;
+            }
+            break;
+        case BOOTSTRAPPER_RELATION_PATCH: __fallthrough;
+        case BOOTSTRAPPER_RELATION_ADDON:
+            if (BOOTSTRAPPER_ACTION_UNINSTALL == pPlan->action)
+            {
+                pRelatedBundle->package.requested = BOOTSTRAPPER_REQUEST_STATE_ABSENT;
+            }
+            else if (BOOTSTRAPPER_ACTION_INSTALL == pPlan->action || BOOTSTRAPPER_ACTION_MODIFY == pPlan->action)
+            {
+                pRelatedBundle->package.requested = BOOTSTRAPPER_REQUEST_STATE_PRESENT;
+            }
+            else if (BOOTSTRAPPER_ACTION_REPAIR == pPlan->action)
+            {
+                pRelatedBundle->package.requested = BOOTSTRAPPER_REQUEST_STATE_REPAIR;
+            }
+            break;
+        case BOOTSTRAPPER_RELATION_DEPENDENT:
+            // Automatically repair dependent bundles to restore missing
+            // packages after uninstall unless we're being upgraded with the
+            // assumption that upgrades are cumulative (as intended).
+            if (BOOTSTRAPPER_RELATION_UPGRADE != relationType && BOOTSTRAPPER_ACTION_UNINSTALL == pPlan->action)
+            {
+                pRelatedBundle->package.requested = BOOTSTRAPPER_REQUEST_STATE_REPAIR;
+            }
+            break;
+        case BOOTSTRAPPER_RELATION_DETECT:
+            break;
+        default:
+            hr = E_UNEXPECTED;
+            ExitOnFailure(hr, "Unexpected relation type encountered during plan: %d", pRelatedBundle->relationType);
+            break;
+        }
+
+        pRelatedBundle->package.defaultRequested = pRelatedBundle->package.requested;
+
+        hr = UserExperienceOnPlanRelatedBundle(pUserExperience, pRelatedBundle->package.sczId, &pRelatedBundle->package.requested);
+        ExitOnRootFailure(hr, "BA aborted plan related bundle.");
+
+        // Log when the BA changed the bundle state so the engine doesn't get blamed for planning the wrong thing.
+        if (pRelatedBundle->package.requested != pRelatedBundle->package.defaultRequested)
+        {
+            LogId(REPORT_STANDARD, MSG_PLANNED_BUNDLE_UX_CHANGED_REQUEST, pRelatedBundle->package.sczId, LoggingRequestStateToString(pRelatedBundle->package.requested), LoggingRequestStateToString(pRelatedBundle->package.defaultRequested));
+        }
+
+        // If uninstalling and the dependent related bundle may be executed, ignore its provider key to allow for downgrades with ref-counting.
+        if (BOOTSTRAPPER_ACTION_UNINSTALL == pPlan->action && BOOTSTRAPPER_RELATION_DEPENDENT == pRelatedBundle->relationType && BOOTSTRAPPER_REQUEST_STATE_NONE != pRelatedBundle->package.requested)
+        {
+            if (0 < pRelatedBundle->package.cDependencyProviders)
+            {
+                // Bundles only support a single provider key.
+                const BURN_DEPENDENCY_PROVIDER* pProvider = pRelatedBundle->package.rgDependencyProviders;
+
+                hr = DepDependencyArrayAlloc(&pPlan->rgPlannedProviders, &pPlan->cPlannedProviders, pProvider->sczKey, pProvider->sczDisplayName);
+                ExitOnFailure(hr, "Failed to add the package provider key \"%ls\" to the planned list.", pProvider->sczKey);
+            }
+        }
+    }
+
+LExit:
+    ReleaseDict(sdAncestors);
+    ReleaseStrArray(rgsczAncestors, cAncestors);
+
+    return hr;
+}
+
+extern "C" HRESULT PlanRelatedBundlesComplete(
+    __in BURN_REGISTRATION* pRegistration,
+    __in BURN_PLAN* pPlan,
+    __in BURN_LOGGING* pLog,
+    __in BURN_VARIABLES* pVariables,
+    __inout HANDLE* phSyncpointEvent,
+    __in DWORD dwExecuteActionEarlyIndex
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR sczIgnoreDependencies = NULL;
+    STRINGDICT_HANDLE sdProviderKeys = NULL;
+
+    // Get the list of dependencies to ignore to pass to related bundles.
+    hr = DependencyAllocIgnoreDependencies(pPlan, &sczIgnoreDependencies);
+    ExitOnFailure(hr, "Failed to get the list of dependencies to ignore.");
+
+    hr = DictCreateStringList(&sdProviderKeys, pPlan->cExecuteActions, DICT_FLAG_CASEINSENSITIVE);
+    ExitOnFailure(hr, "Failed to create dictionary for planned packages.");
+
+    BOOL fExecutingAnyPackage = FALSE;
+
+    for (DWORD i = 0; i < pPlan->cExecuteActions; ++i)
+    {
+        if (BURN_EXECUTE_ACTION_TYPE_EXE_PACKAGE == pPlan->rgExecuteActions[i].type && BOOTSTRAPPER_ACTION_STATE_NONE != pPlan->rgExecuteActions[i].exePackage.action)
+        {
+            fExecutingAnyPackage = TRUE;
+
+            BURN_PACKAGE* pPackage = pPlan->rgExecuteActions[i].packageProvider.pPackage;
+            if (BURN_PACKAGE_TYPE_EXE == pPackage->type && BURN_EXE_PROTOCOL_TYPE_BURN == pPackage->Exe.protocol)
+            {
+                if (0 < pPackage->cDependencyProviders)
+                {
+                    // Bundles only support a single provider key.
+                    const BURN_DEPENDENCY_PROVIDER* pProvider = pPackage->rgDependencyProviders;
+                    DictAddKey(sdProviderKeys, pProvider->sczKey);
+                }
+            }
+        }
+        else
+        {
+            switch (pPlan->rgExecuteActions[i].type)
+            {
+            case BURN_EXECUTE_ACTION_TYPE_MSI_PACKAGE:
+                fExecutingAnyPackage |= (BOOTSTRAPPER_ACTION_STATE_NONE != pPlan->rgExecuteActions[i].msiPackage.action);
+                break;
+
+            case BURN_EXECUTE_ACTION_TYPE_MSP_TARGET:
+                fExecutingAnyPackage |= (BOOTSTRAPPER_ACTION_STATE_NONE != pPlan->rgExecuteActions[i].mspTarget.action);
+                break;
+
+            case BURN_EXECUTE_ACTION_TYPE_MSU_PACKAGE:
+                fExecutingAnyPackage |= (BOOTSTRAPPER_ACTION_STATE_NONE != pPlan->rgExecuteActions[i].msuPackage.action);
+                break;
+            }
+        }
+    }
+
+    for (DWORD i = 0; i < pRegistration->relatedBundles.cRelatedBundles; ++i)
+    {
+        DWORD *pdwInsertIndex = NULL;
+        BURN_RELATED_BUNDLE* pRelatedBundle = pRegistration->relatedBundles.rgRelatedBundles + i;
+
+        // Do not execute if a major upgrade to the related bundle is an embedded bundle (Provider keys are the same)
+        if (0 < pRelatedBundle->package.cDependencyProviders)
+        {
+            // Bundles only support a single provider key.
+            const BURN_DEPENDENCY_PROVIDER* pProvider = pRelatedBundle->package.rgDependencyProviders;
+            hr = DictKeyExists(sdProviderKeys, pProvider->sczKey);
+            if (E_NOTFOUND != hr)
+            {
+                ExitOnFailure(hr, "Failed to check the dictionary for a related bundle provider key: \"%ls\".", pProvider->sczKey);
+                // Key found, so there is an embedded bundle with the same provider key that will be executed.  So this related bundle should not be added to the plan
+                LogId(REPORT_STANDARD, MSG_PLAN_SKIPPED_RELATED_BUNDLE_EMBEDDED_BUNDLE_NEWER, pRelatedBundle->package.sczId, LoggingRelationTypeToString(pRelatedBundle->relationType), pProvider->sczKey);
+                continue;
+            }
+            else
+            {
+                hr = S_OK;
+            }
+        }
+
+        // For an uninstall, there is no need to repair dependent bundles if no packages are executing.
+        if (!fExecutingAnyPackage && BOOTSTRAPPER_RELATION_DEPENDENT == pRelatedBundle->relationType && BOOTSTRAPPER_REQUEST_STATE_REPAIR == pRelatedBundle->package.requested && BOOTSTRAPPER_ACTION_UNINSTALL == pPlan->action)
+        {
+            pRelatedBundle->package.requested = BOOTSTRAPPER_REQUEST_STATE_NONE;
+            LogId(REPORT_STANDARD, MSG_PLAN_SKIPPED_DEPENDENT_BUNDLE_REPAIR, pRelatedBundle->package.sczId, LoggingRelationTypeToString(pRelatedBundle->relationType));
+        }
+
+        if (BOOTSTRAPPER_RELATION_ADDON == pRelatedBundle->relationType || BOOTSTRAPPER_RELATION_PATCH == pRelatedBundle->relationType)
+        {
+            // Addon and patch bundles will be passed a list of dependencies to ignore for planning.
+            hr = StrAllocString(&pRelatedBundle->package.Exe.sczIgnoreDependencies, sczIgnoreDependencies, 0);
+            ExitOnFailure(hr, "Failed to copy the list of dependencies to ignore.");
+
+            // Uninstall addons and patches early in the chain, before other packages are uninstalled.
+            if (BOOTSTRAPPER_ACTION_UNINSTALL == pPlan->action)
+            {
+                pdwInsertIndex = &dwExecuteActionEarlyIndex;
+            }
+        }
+
+        if (BOOTSTRAPPER_REQUEST_STATE_NONE != pRelatedBundle->package.requested)
+        {
+            hr = ExeEnginePlanCalculatePackage(&pRelatedBundle->package, NULL);
+            ExitOnFailure(hr, "Failed to calcuate plan for related bundle: %ls", pRelatedBundle->package.sczId);
+
+            // Calculate package states based on reference count for addon and patch related bundles.
+            if (BOOTSTRAPPER_RELATION_ADDON == pRelatedBundle->relationType || BOOTSTRAPPER_RELATION_PATCH == pRelatedBundle->relationType)
+            {
+                hr = DependencyPlanPackageBegin(pRegistration->fPerMachine, &pRelatedBundle->package, pPlan);
+                ExitOnFailure(hr, "Failed to begin plan dependency actions to  package: %ls", pRelatedBundle->package.sczId);
+
+                // If uninstalling a related bundle, make sure the bundle is uninstalled after removing registration.
+                if (pdwInsertIndex && BOOTSTRAPPER_ACTION_UNINSTALL == pPlan->action)
+                {
+                    ++(*pdwInsertIndex);
+                }
+            }
+
+            hr = ExeEnginePlanAddPackage(pdwInsertIndex, &pRelatedBundle->package, pPlan, pLog, pVariables, *phSyncpointEvent, FALSE);
+            ExitOnFailure(hr, "Failed to add to plan related bundle: %ls", pRelatedBundle->package.sczId);
+
+            // Calculate package states based on reference count for addon and patch related bundles.
+            if (BOOTSTRAPPER_RELATION_ADDON == pRelatedBundle->relationType || BOOTSTRAPPER_RELATION_PATCH == pRelatedBundle->relationType)
+            {
+                hr = DependencyPlanPackageComplete(&pRelatedBundle->package, pPlan);
+                ExitOnFailure(hr, "Failed to complete plan dependency actions for related bundle package: %ls", pRelatedBundle->package.sczId);
+            }
+
+            // If we are going to take any action on this package, add progress for it.
+            if (BOOTSTRAPPER_ACTION_STATE_NONE != pRelatedBundle->package.execute || BOOTSTRAPPER_ACTION_STATE_NONE != pRelatedBundle->package.rollback)
+            {
+                LoggingIncrementPackageSequence();
+
+                ++pPlan->cExecutePackagesTotal;
+                ++pPlan->cOverallProgressTicksTotal;
+            }
+
+            // If package is per-machine and is being executed, flag the plan to be per-machine as well.
+            if (pRelatedBundle->package.fPerMachine)
+            {
+                pPlan->fPerMachine = TRUE;
+            }
+        }
+        else if (BOOTSTRAPPER_RELATION_ADDON == pRelatedBundle->relationType || BOOTSTRAPPER_RELATION_PATCH == pRelatedBundle->relationType)
+        {
+            // Make sure the package is properly ref-counted even if no plan is requested.
+            hr = DependencyPlanPackageBegin(pRegistration->fPerMachine, &pRelatedBundle->package, pPlan);
+            ExitOnFailure(hr, "Failed to begin plan dependency actions for related bundle package: %ls", pRelatedBundle->package.sczId);
+
+            hr = DependencyPlanPackage(pdwInsertIndex, &pRelatedBundle->package, pPlan);
+            ExitOnFailure(hr, "Failed to plan related bundle package provider actions.");
+
+            hr = DependencyPlanPackageComplete(&pRelatedBundle->package, pPlan);
+            ExitOnFailure(hr, "Failed to complete plan dependency actions for related bundle package: %ls", pRelatedBundle->package.sczId);
+        }
+    }
+
+LExit:
+    ReleaseDict(sdProviderKeys);
+    ReleaseStr(sczIgnoreDependencies);
+
+    return hr;
+}
+
+extern "C" HRESULT PlanFinalizeActions(
+    __in BURN_PLAN* pPlan
+    )
+{
+    HRESULT hr = S_OK;
+
+    hr = RemoveUnnecessaryActions(TRUE, pPlan->rgExecuteActions, pPlan->cExecuteActions);
+    ExitOnFailure(hr, "Failed to remove unnecessary execute actions.");
+
+    hr = RemoveUnnecessaryActions(FALSE, pPlan->rgRollbackActions, pPlan->cRollbackActions);
+    ExitOnFailure(hr, "Failed to remove unnecessary execute actions.");
+
+    hr = FinalizeSlipstreamPatchActions(TRUE, pPlan->rgExecuteActions, pPlan->cExecuteActions);
+    ExitOnFailure(hr, "Failed to finalize slipstream execute actions.");
+
+    hr = FinalizeSlipstreamPatchActions(FALSE, pPlan->rgRollbackActions, pPlan->cRollbackActions);
+    ExitOnFailure(hr, "Failed to finalize slipstream rollback actions.");
+
+LExit:
+    return hr;
+}
+
+extern "C" HRESULT PlanCleanPackage(
+    __in BURN_PLAN* pPlan,
+    __in BURN_PACKAGE* pPackage
+    )
+{
+    HRESULT hr = S_OK;
+    BOOL fPlanCleanPackage = FALSE;
+    BURN_CLEAN_ACTION* pCleanAction = NULL;
+
+    // The following is a complex set of logic that determines when a package should be cleaned
+    // from the cache. Start by noting that we only clean if the package is being acquired or
+    // already cached and the package is not supposed to always be cached.
+    if ((pPackage->fAcquire || BURN_CACHE_STATE_PARTIAL == pPackage->cache || BURN_CACHE_STATE_COMPLETE == pPackage->cache) &&
+        (BURN_CACHE_TYPE_ALWAYS > pPackage->cacheType || BOOTSTRAPPER_ACTION_INSTALL > pPlan->action))
+    {
+        // The following are all different reasons why the package should be cleaned from the cache.
+        // The else-ifs are used to make the conditions easier to see (rather than have them combined
+        // in one huge condition).
+        if (BURN_CACHE_TYPE_YES > pPackage->cacheType)  // easy, package is not supposed to stay cached.
+        {
+            fPlanCleanPackage = TRUE;
+        }
+        else if ((BOOTSTRAPPER_REQUEST_STATE_FORCE_ABSENT == pPackage->requested ||
+                  BOOTSTRAPPER_REQUEST_STATE_ABSENT == pPackage->requested) &&      // requested to be removed and
+                 BOOTSTRAPPER_ACTION_STATE_UNINSTALL == pPackage->execute)          // actually being removed.
+        {
+            fPlanCleanPackage = TRUE;
+        }
+        else if ((BOOTSTRAPPER_REQUEST_STATE_FORCE_ABSENT == pPackage->requested ||
+                  BOOTSTRAPPER_REQUEST_STATE_ABSENT == pPackage->requested) &&      // requested to be removed but
+                 BOOTSTRAPPER_ACTION_STATE_NONE == pPackage->execute &&             // execute is do nothing and
+                 !pPackage->fDependencyManagerWasHere &&                            // dependency manager didn't change execute and
+                 BOOTSTRAPPER_PACKAGE_STATE_PRESENT > pPackage->currentState)       // currently not installed.
+        {
+            fPlanCleanPackage = TRUE;
+        }
+        else if (BOOTSTRAPPER_ACTION_UNINSTALL == pPlan->action &&                  // uninstalling and
+                 BOOTSTRAPPER_REQUEST_STATE_NONE == pPackage->requested &&          // requested do nothing (aka: default) and
+                 BOOTSTRAPPER_ACTION_STATE_NONE == pPackage->execute &&             // execute is still do nothing and
+                 !pPackage->fDependencyManagerWasHere &&                            // dependency manager didn't change execute and
+                 BOOTSTRAPPER_PACKAGE_STATE_PRESENT > pPackage->currentState)       // currently not installed.
+        {
+            fPlanCleanPackage = TRUE;
+        }
+    }
+
+    if (fPlanCleanPackage)
+    {
+        hr = MemEnsureArraySize(reinterpret_cast<LPVOID*>(&pPlan->rgCleanActions), pPlan->cCleanActions + 1, sizeof(BURN_CLEAN_ACTION), 5);
+        ExitOnFailure(hr, "Failed to grow plan's array of clean actions.");
+
+        pCleanAction = pPlan->rgCleanActions + pPlan->cCleanActions;
+        ++pPlan->cCleanActions;
+
+        pCleanAction->pPackage = pPackage;
+
+        pPackage->fUncache = TRUE;
+    }
+
+LExit:
+    return hr;
+}
+
+extern "C" HRESULT PlanExecuteCacheSyncAndRollback(
+    __in BURN_PLAN* pPlan,
+    __in BURN_PACKAGE* pPackage,
+    __in HANDLE hCacheEvent,
+    __in BOOL fPlanPackageCacheRollback
+    )
+{
+    HRESULT hr = S_OK;
+    BURN_EXECUTE_ACTION* pAction = NULL;
+
+    hr = PlanAppendExecuteAction(pPlan, &pAction);
+    ExitOnFailure(hr, "Failed to append wait action for caching.");
+
+    pAction->type = BURN_EXECUTE_ACTION_TYPE_WAIT_SYNCPOINT;
+    pAction->syncpoint.hEvent = hCacheEvent;
+
+    if (fPlanPackageCacheRollback)
+    {
+        hr = PlanAppendRollbackAction(pPlan, &pAction);
+        ExitOnFailure(hr, "Failed to append rollback action.");
+
+        pAction->type = BURN_EXECUTE_ACTION_TYPE_UNCACHE_PACKAGE;
+        pAction->uncachePackage.pPackage = pPackage;
+
+        hr = PlanExecuteCheckpoint(pPlan);
+        ExitOnFailure(hr, "Failed to append execute checkpoint for cache rollback.");
+    }
+
+LExit:
+    return hr;
+}
+
+extern "C" HRESULT PlanExecuteCheckpoint(
+    __in BURN_PLAN* pPlan
+    )
+{
+    HRESULT hr = S_OK;
+    BURN_EXECUTE_ACTION* pAction = NULL;
+    DWORD dwCheckpointId = GetNextCheckpointId();
+
+    // execute checkpoint
+    hr = PlanAppendExecuteAction(pPlan, &pAction);
+    ExitOnFailure(hr, "Failed to append execute action.");
+
+    pAction->type = BURN_EXECUTE_ACTION_TYPE_CHECKPOINT;
+    pAction->checkpoint.dwId = dwCheckpointId;
+
+    // rollback checkpoint
+    hr = PlanAppendRollbackAction(pPlan, &pAction);
+    ExitOnFailure(hr, "Failed to append rollback action.");
+
+    pAction->type = BURN_EXECUTE_ACTION_TYPE_CHECKPOINT;
+    pAction->checkpoint.dwId = dwCheckpointId;
+
+LExit:
+    return hr;
+}
+
+extern "C" HRESULT PlanInsertExecuteAction(
+    __in DWORD dwIndex,
+    __in BURN_PLAN* pPlan,
+    __out BURN_EXECUTE_ACTION** ppExecuteAction
+    )
+{
+    HRESULT hr = S_OK;
+
+    hr = MemInsertIntoArray((void**)&pPlan->rgExecuteActions, dwIndex, 1, pPlan->cExecuteActions + 1, sizeof(BURN_EXECUTE_ACTION), 5);
+    ExitOnFailure(hr, "Failed to grow plan's array of execute actions.");
+
+    *ppExecuteAction = pPlan->rgExecuteActions + dwIndex;
+    ++pPlan->cExecuteActions;
+
+LExit:
+    return hr;
+}
+
+extern "C" HRESULT PlanInsertRollbackAction(
+    __in DWORD dwIndex,
+    __in BURN_PLAN* pPlan,
+    __out BURN_EXECUTE_ACTION** ppRollbackAction
+    )
+{
+    HRESULT hr = S_OK;
+
+    hr = MemInsertIntoArray((void**)&pPlan->rgRollbackActions, dwIndex, 1, pPlan->cRollbackActions + 1, sizeof(BURN_EXECUTE_ACTION), 5);
+    ExitOnFailure(hr, "Failed to grow plan's array of rollback actions.");
+
+    *ppRollbackAction = pPlan->rgRollbackActions + dwIndex;
+    ++pPlan->cRollbackActions;
+
+LExit:
+    return hr;
+}
+
+extern "C" HRESULT PlanAppendExecuteAction(
+    __in BURN_PLAN* pPlan,
+    __out BURN_EXECUTE_ACTION** ppExecuteAction
+    )
+{
+    HRESULT hr = S_OK;
+
+    hr = MemEnsureArraySize((void**)&pPlan->rgExecuteActions, pPlan->cExecuteActions + 1, sizeof(BURN_EXECUTE_ACTION), 5);
+    ExitOnFailure(hr, "Failed to grow plan's array of execute actions.");
+
+    *ppExecuteAction = pPlan->rgExecuteActions + pPlan->cExecuteActions;
+    ++pPlan->cExecuteActions;
+
+LExit:
+    return hr;
+}
+
+extern "C" HRESULT PlanAppendRollbackAction(
+    __in BURN_PLAN* pPlan,
+    __out BURN_EXECUTE_ACTION** ppRollbackAction
+    )
+{
+    HRESULT hr = S_OK;
+
+    hr = MemEnsureArraySize((void**)&pPlan->rgRollbackActions, pPlan->cRollbackActions + 1, sizeof(BURN_EXECUTE_ACTION), 5);
+    ExitOnFailure(hr, "Failed to grow plan's array of rollback actions.");
+
+    *ppRollbackAction = pPlan->rgRollbackActions + pPlan->cRollbackActions;
+    ++pPlan->cRollbackActions;
+
+LExit:
+    return hr;
+}
+
+extern "C" HRESULT PlanKeepRegistration(
+    __in BURN_PLAN* pPlan,
+    __in DWORD iAfterExecutePackageAction,
+    __in DWORD iBeforeRollbackPackageAction
+    )
+{
+    HRESULT hr = S_OK;
+    BURN_EXECUTE_ACTION* pAction = NULL;
+
+    if (BURN_PLAN_INVALID_ACTION_INDEX != iAfterExecutePackageAction)
+    {
+        hr = PlanInsertExecuteAction(iAfterExecutePackageAction, pPlan, &pAction);
+        ExitOnFailure(hr, "Failed to insert keep registration execute action.");
+
+        pAction->type = BURN_EXECUTE_ACTION_TYPE_REGISTRATION;
+        pAction->registration.fKeep = TRUE;
+    }
+
+    if (BURN_PLAN_INVALID_ACTION_INDEX != iBeforeRollbackPackageAction)
+    {
+        hr = PlanInsertRollbackAction(iBeforeRollbackPackageAction, pPlan, &pAction);
+        ExitOnFailure(hr, "Failed to insert keep registration rollback action.");
+
+        pAction->type = BURN_EXECUTE_ACTION_TYPE_REGISTRATION;
+        pAction->registration.fKeep = FALSE;
+    }
+
+LExit:
+    return hr;
+}
+
+extern "C" HRESULT PlanRemoveRegistration(
+    __in BURN_PLAN* pPlan,
+    __in DWORD iAfterExecutePackageAction,
+    __in DWORD iAfterRollbackPackageAction
+    )
+{
+    HRESULT hr = S_OK;
+    BURN_EXECUTE_ACTION* pAction = NULL;
+
+    if (BURN_PLAN_INVALID_ACTION_INDEX != iAfterExecutePackageAction)
+    {
+        hr = PlanInsertExecuteAction(iAfterExecutePackageAction, pPlan, &pAction);
+        ExitOnFailure(hr, "Failed to insert remove registration execute action.");
+
+        pAction->type = BURN_EXECUTE_ACTION_TYPE_REGISTRATION;
+        pAction->registration.fKeep = FALSE;
+    }
+
+    if (BURN_PLAN_INVALID_ACTION_INDEX != iAfterRollbackPackageAction)
+    {
+        hr = PlanInsertRollbackAction(iAfterRollbackPackageAction, pPlan, &pAction);
+        ExitOnFailure(hr, "Failed to insert remove registration rollback action.");
+
+        pAction->type = BURN_EXECUTE_ACTION_TYPE_REGISTRATION;
+        pAction->registration.fKeep = TRUE;
+    }
+
+LExit:
+    return hr;
+}
+
+extern "C" HRESULT PlanRollbackBoundaryBegin(
+    __in BURN_PLAN* pPlan,
+    __in BURN_ROLLBACK_BOUNDARY* pRollbackBoundary
+    )
+{
+    HRESULT hr = S_OK;
+    BURN_EXECUTE_ACTION* pExecuteAction = NULL;
+
+    // Add begin rollback boundary to execute plan.
+    hr = PlanAppendExecuteAction(pPlan, &pExecuteAction);
+    ExitOnFailure(hr, "Failed to append rollback boundary begin action.");
+
+    pExecuteAction->type = BURN_EXECUTE_ACTION_TYPE_ROLLBACK_BOUNDARY;
+    pExecuteAction->rollbackBoundary.pRollbackBoundary = pRollbackBoundary;
+
+    // Add begin rollback boundary to rollback plan.
+    hr = PlanAppendRollbackAction(pPlan, &pExecuteAction);
+    ExitOnFailure(hr, "Failed to append rollback boundary begin action.");
+
+    pExecuteAction->type = BURN_EXECUTE_ACTION_TYPE_ROLLBACK_BOUNDARY;
+    pExecuteAction->rollbackBoundary.pRollbackBoundary = pRollbackBoundary;
+
+LExit:
+    return hr;
+}
+
+extern "C" HRESULT PlanRollbackBoundaryComplete(
+    __in BURN_PLAN* pPlan
+    )
+{
+    HRESULT hr = S_OK;
+    BURN_EXECUTE_ACTION* pExecuteAction = NULL;
+    DWORD dwCheckpointId = 0;
+
+    // Add checkpoints.
+    dwCheckpointId = GetNextCheckpointId();
+
+    hr = PlanAppendExecuteAction(pPlan, &pExecuteAction);
+    ExitOnFailure(hr, "Failed to append execute action.");
+
+    pExecuteAction->type = BURN_EXECUTE_ACTION_TYPE_CHECKPOINT;
+    pExecuteAction->checkpoint.dwId = dwCheckpointId;
+
+    hr = PlanAppendRollbackAction(pPlan, &pExecuteAction);
+    ExitOnFailure(hr, "Failed to append rollback action.");
+
+    pExecuteAction->type = BURN_EXECUTE_ACTION_TYPE_CHECKPOINT;
+    pExecuteAction->checkpoint.dwId = dwCheckpointId;
+
+LExit:
+    return hr;
+}
+
+/*******************************************************************
+ PlanSetResumeCommand - Initializes resume command string
+
+*******************************************************************/
+extern "C" HRESULT PlanSetResumeCommand(
+    __in BURN_REGISTRATION* pRegistration,
+    __in BOOTSTRAPPER_ACTION action,
+    __in BOOTSTRAPPER_COMMAND* pCommand,
+    __in BURN_LOGGING* pLog
+    )
+{
+    HRESULT hr = S_OK;
+
+    // build the resume command-line.
+    hr = CoreRecreateCommandLine(&pRegistration->sczResumeCommandLine, action, pCommand->display, pCommand->restart, pCommand->relationType, pCommand->fPassthrough, pRegistration->sczActiveParent, pRegistration->sczAncestors, pLog->sczPath, pCommand->wzCommandLine);
+    ExitOnFailure(hr, "Failed to recreate resume command-line.");
+
+LExit:
+    return hr;
+}
+
+
+// internal function definitions
+
+static void UninitializeRegistrationAction(
+    __in BURN_DEPENDENT_REGISTRATION_ACTION* pAction
+    )
+{
+    ReleaseStr(pAction->sczDependentProviderKey);
+    ReleaseStr(pAction->sczBundleId);
+    memset(pAction, 0, sizeof(BURN_DEPENDENT_REGISTRATION_ACTION));
+}
+
+static void UninitializeCacheAction(
+    __in BURN_CACHE_ACTION* pCacheAction
+    )
+{
+    switch (pCacheAction->type)
+    {
+    case BURN_CACHE_ACTION_TYPE_SIGNAL_SYNCPOINT:
+        ReleaseHandle(pCacheAction->syncpoint.hEvent);
+        break;
+
+    case BURN_CACHE_ACTION_TYPE_LAYOUT_BUNDLE:
+        ReleaseStr(pCacheAction->bundleLayout.sczExecutableName);
+        ReleaseStr(pCacheAction->bundleLayout.sczLayoutDirectory);
+        ReleaseStr(pCacheAction->bundleLayout.sczUnverifiedPath);
+        break;
+
+    case BURN_CACHE_ACTION_TYPE_ACQUIRE_CONTAINER:
+        ReleaseStr(pCacheAction->resolveContainer.sczUnverifiedPath);
+        break;
+
+    case BURN_CACHE_ACTION_TYPE_EXTRACT_CONTAINER:
+        ReleaseStr(pCacheAction->extractContainer.sczContainerUnverifiedPath);
+        ReleaseMem(pCacheAction->extractContainer.rgPayloads);
+        break;
+
+    case BURN_CACHE_ACTION_TYPE_ACQUIRE_PAYLOAD:
+        ReleaseStr(pCacheAction->resolvePayload.sczUnverifiedPath);
+        break;
+
+    case BURN_CACHE_ACTION_TYPE_CACHE_PAYLOAD:
+        ReleaseStr(pCacheAction->cachePayload.sczUnverifiedPath);
+        break;
+    }
+}
+
+static void ResetPlannedPackageState(
+    __in BURN_PACKAGE* pPackage
+    )
+{
+    // Reset package state that is a result of planning.
+    pPackage->expected = BOOTSTRAPPER_PACKAGE_STATE_UNKNOWN;
+    pPackage->defaultRequested = BOOTSTRAPPER_REQUEST_STATE_NONE;
+    pPackage->requested = BOOTSTRAPPER_REQUEST_STATE_NONE;
+    pPackage->fAcquire = FALSE;
+    pPackage->fUncache = FALSE;
+    pPackage->execute = BOOTSTRAPPER_ACTION_STATE_NONE;
+    pPackage->rollback = BOOTSTRAPPER_ACTION_STATE_NONE;
+    pPackage->providerExecute = BURN_DEPENDENCY_ACTION_NONE;
+    pPackage->providerRollback = BURN_DEPENDENCY_ACTION_NONE;
+    pPackage->dependencyExecute = BURN_DEPENDENCY_ACTION_NONE;
+    pPackage->dependencyRollback = BURN_DEPENDENCY_ACTION_NONE;
+    pPackage->fDependencyManagerWasHere = FALSE;
+
+    if (BURN_PACKAGE_TYPE_MSI == pPackage->type && pPackage->Msi.rgFeatures)
+    {
+        for (DWORD i = 0; i < pPackage->Msi.cFeatures; ++i)
+        {
+            BURN_MSIFEATURE* pFeature = &pPackage->Msi.rgFeatures[i];
+
+            pFeature->execute = BOOTSTRAPPER_FEATURE_ACTION_NONE;
+            pFeature->rollback = BOOTSTRAPPER_FEATURE_ACTION_NONE;
+        }
+    }
+    else if (BURN_PACKAGE_TYPE_MSP == pPackage->type && pPackage->Msp.rgTargetProducts)
+    {
+        for (DWORD i = 0; i < pPackage->Msp.cTargetProductCodes; ++i)
+        {
+            BURN_MSPTARGETPRODUCT* pTargetProduct = &pPackage->Msp.rgTargetProducts[i];
+
+            pTargetProduct->execute = BOOTSTRAPPER_ACTION_STATE_NONE;
+            pTargetProduct->rollback = BOOTSTRAPPER_ACTION_STATE_NONE;
+        }
+    }
+}
+
+static HRESULT GetActionDefaultRequestState(
+    __in BOOTSTRAPPER_ACTION action,
+    __in BOOL fPermanent,
+    __in BOOTSTRAPPER_PACKAGE_STATE currentState,
+    __out BOOTSTRAPPER_REQUEST_STATE* pRequestState
+    )
+{
+    HRESULT hr = S_OK;
+
+    switch (action)
+    {
+    case BOOTSTRAPPER_ACTION_CACHE:
+        switch (currentState)
+        {
+        case BOOTSTRAPPER_PACKAGE_STATE_PRESENT:
+            *pRequestState = BOOTSTRAPPER_REQUEST_STATE_PRESENT;
+            break;
+
+        case BOOTSTRAPPER_PACKAGE_STATE_CACHED:
+            *pRequestState = BOOTSTRAPPER_REQUEST_STATE_NONE;
+            break;
+
+        default:
+            *pRequestState = BOOTSTRAPPER_REQUEST_STATE_CACHE;
+            break;
+        }
+        break;
+
+    case BOOTSTRAPPER_ACTION_INSTALL: __fallthrough;
+    case BOOTSTRAPPER_ACTION_UPDATE_REPLACE: __fallthrough;
+    case BOOTSTRAPPER_ACTION_UPDATE_REPLACE_EMBEDDED:
+        *pRequestState = BOOTSTRAPPER_REQUEST_STATE_PRESENT;
+        break;
+
+    case BOOTSTRAPPER_ACTION_REPAIR:
+        *pRequestState = BOOTSTRAPPER_REQUEST_STATE_REPAIR;
+        break;
+
+    case BOOTSTRAPPER_ACTION_UNINSTALL:
+        *pRequestState = fPermanent ? BOOTSTRAPPER_REQUEST_STATE_NONE : BOOTSTRAPPER_REQUEST_STATE_ABSENT;
+        break;
+
+    case BOOTSTRAPPER_ACTION_MODIFY:
+        switch (currentState)
+        {
+        case BOOTSTRAPPER_PACKAGE_STATE_ABSENT:
+            *pRequestState = BOOTSTRAPPER_REQUEST_STATE_ABSENT;
+            break;
+
+        case BOOTSTRAPPER_PACKAGE_STATE_CACHED:
+            *pRequestState = BOOTSTRAPPER_REQUEST_STATE_CACHE;
+            break;
+
+        case BOOTSTRAPPER_PACKAGE_STATE_PRESENT:
+            *pRequestState = BOOTSTRAPPER_REQUEST_STATE_PRESENT;
+            break;
+
+        default:
+            *pRequestState = BOOTSTRAPPER_REQUEST_STATE_NONE;
+            break;
+        }
+        break;
+
+    default:
+        hr = E_INVALIDARG;
+        ExitOnRootFailure(hr, "Invalid action state.");
+    }
+
+LExit:
+        return hr;
+}
+
+static HRESULT AddRegistrationAction(
+    __in BURN_PLAN* pPlan,
+    __in BURN_DEPENDENT_REGISTRATION_ACTION_TYPE type,
+    __in_z LPCWSTR wzDependentProviderKey,
+    __in_z LPCWSTR wzOwnerBundleId
+    )
+{
+    HRESULT hr = S_OK;
+    BURN_DEPENDENT_REGISTRATION_ACTION_TYPE rollbackType = (BURN_DEPENDENT_REGISTRATION_ACTION_TYPE_REGISTER == type) ? BURN_DEPENDENT_REGISTRATION_ACTION_TYPE_UNREGISTER : BURN_DEPENDENT_REGISTRATION_ACTION_TYPE_REGISTER;
+    BURN_DEPENDENT_REGISTRATION_ACTION* pAction = NULL;
+
+    // Create forward registration action.
+    hr = MemEnsureArraySize((void**)&pPlan->rgRegistrationActions, pPlan->cRegistrationActions + 1, sizeof(BURN_DEPENDENT_REGISTRATION_ACTION), 5);
+    ExitOnFailure(hr, "Failed to grow plan's array of registration actions.");
+
+    pAction = pPlan->rgRegistrationActions + pPlan->cRegistrationActions;
+    ++pPlan->cRegistrationActions;
+
+    pAction->type = type;
+
+    hr = StrAllocString(&pAction->sczBundleId, wzOwnerBundleId, 0);
+    ExitOnFailure(hr, "Failed to copy owner bundle to registration action.");
+
+    hr = StrAllocString(&pAction->sczDependentProviderKey, wzDependentProviderKey, 0);
+    ExitOnFailure(hr, "Failed to copy dependent provider key to registration action.");
+
+    // Create rollback registration action.
+    hr = MemEnsureArraySize((void**)&pPlan->rgRollbackRegistrationActions, pPlan->cRollbackRegistrationActions + 1, sizeof(BURN_DEPENDENT_REGISTRATION_ACTION), 5);
+    ExitOnFailure(hr, "Failed to grow plan's array of rollback registration actions.");
+
+    pAction = pPlan->rgRollbackRegistrationActions + pPlan->cRollbackRegistrationActions;
+    ++pPlan->cRollbackRegistrationActions;
+
+    pAction->type = rollbackType;
+
+    hr = StrAllocString(&pAction->sczBundleId, wzOwnerBundleId, 0);
+    ExitOnFailure(hr, "Failed to copy owner bundle to registration action.");
+
+    hr = StrAllocString(&pAction->sczDependentProviderKey, wzDependentProviderKey, 0);
+    ExitOnFailure(hr, "Failed to copy dependent provider key to rollback registration action.");
+
+LExit:
+    return hr;
+}
+
+static HRESULT AddCachePackage(
+    __in BURN_PLAN* pPlan,
+    __in BURN_PACKAGE* pPackage,
+    __out HANDLE* phSyncpointEvent
+    )
+{
+    HRESULT hr = S_OK;
+
+    // If this is an MSI package with slipstream MSPs, ensure the MSPs are cached first.
+    if (BURN_PACKAGE_TYPE_MSI == pPackage->type && 0 < pPackage->Msi.cSlipstreamMspPackages)
+    {
+        hr = AddCacheSlipstreamMsps(pPlan, pPackage);
+        ExitOnFailure(hr, "Failed to plan slipstream patches for package.");
+    }
+
+    hr = AddCachePackageHelper(pPlan, pPackage, phSyncpointEvent);
+    ExitOnFailure(hr, "Failed to plan cache package.");
+
+LExit:
+    return hr;
+}
+
+static HRESULT AddCachePackageHelper(
+    __in BURN_PLAN* pPlan,
+    __in BURN_PACKAGE* pPackage,
+    __out HANDLE* phSyncpointEvent
+    )
+{
+    AssertSz(pPackage->sczCacheId && *pPackage->sczCacheId, "AddCachePackageHelper() expects the package to have a cache id.");
+
+    HRESULT hr = S_OK;
+    BURN_CACHE_ACTION* pCacheAction = NULL;
+    DWORD dwCheckpoint = 0;
+    DWORD iPackageStartAction = 0;
+
+    BOOL fPlanned = AlreadyPlannedCachePackage(pPlan, pPackage->sczId, phSyncpointEvent);
+    if (fPlanned)
+    {
+        ExitFunction();
+    }
+
+    // Cache checkpoints happen before the package is cached because downloading packages'
+    // payloads will not roll themselves back the way installation packages rollback on
+    // failure automatically.
+    dwCheckpoint = GetNextCheckpointId();
+
+    hr = AppendCacheAction(pPlan, &pCacheAction);
+    ExitOnFailure(hr, "Failed to append package start action.");
+
+    pCacheAction->type = BURN_CACHE_ACTION_TYPE_CHECKPOINT;
+    pCacheAction->checkpoint.dwId = dwCheckpoint;
+
+    // Only plan the cache rollback if the package is also going to be uninstalled;
+    // otherwise, future operations like repair will not be able to locate the cached package.
+    BOOL fPlanCacheRollback = (BOOTSTRAPPER_ACTION_STATE_UNINSTALL == pPackage->rollback);
+
+    if (fPlanCacheRollback)
+    {
+        hr = AppendRollbackCacheAction(pPlan, &pCacheAction);
+        ExitOnFailure(hr, "Failed to append rollback cache action.");
+
+        pCacheAction->type = BURN_CACHE_ACTION_TYPE_CHECKPOINT;
+        pCacheAction->checkpoint.dwId = dwCheckpoint;
+    }
+
+    // Plan the package start.
+    hr = AppendCacheAction(pPlan, &pCacheAction);
+    ExitOnFailure(hr, "Failed to append package start action.");
+
+    pCacheAction->type = BURN_CACHE_ACTION_TYPE_PACKAGE_START;
+    pCacheAction->packageStart.pPackage = pPackage;
+
+    // Remember the index for the package start action (which is now the last in the cache
+    // actions array) because we have to update this action after processing all the payloads
+    // and the array may be resized later which would move a pointer around in memory.
+    iPackageStartAction = pPlan->cCacheActions - 1;
+
+    if (fPlanCacheRollback)
+    {
+        // Create a package cache rollback action.
+        hr = AppendRollbackCacheAction(pPlan, &pCacheAction);
+        ExitOnFailure(hr, "Failed to append rollback cache action.");
+
+        pCacheAction->type = BURN_CACHE_ACTION_TYPE_ROLLBACK_PACKAGE;
+        pCacheAction->rollbackPackage.pPackage = pPackage;
+    }
+
+    // Add all the payload cache operations to the plan for this package.
+    for (DWORD i = 0; i < pPackage->cPayloads; ++i)
+    {
+        BURN_PACKAGE_PAYLOAD* pPackagePayload = &pPackage->rgPayloads[i];
+
+        hr = AppendCacheOrLayoutPayloadAction(pPlan, pPackage, iPackageStartAction, pPackagePayload->pPayload, pPackagePayload->fCached, NULL);
+        ExitOnFailure(hr, "Failed to append payload cache action.");
+
+        Assert(BURN_CACHE_ACTION_TYPE_PACKAGE_START == pPlan->rgCacheActions[iPackageStartAction].type);
+        ++pPlan->rgCacheActions[iPackageStartAction].packageStart.cCachePayloads;
+        pPlan->rgCacheActions[iPackageStartAction].packageStart.qwCachePayloadSizeTotal += pPackagePayload->pPayload->qwFileSize;
+    }
+
+    // Create package stop action.
+    hr = AppendCacheAction(pPlan, &pCacheAction);
+    ExitOnFailure(hr, "Failed to append cache action.");
+
+    pCacheAction->type = BURN_CACHE_ACTION_TYPE_PACKAGE_STOP;
+    pCacheAction->packageStop.pPackage = pPackage;
+
+    // Update the start action with the location of the complete action.
+    pPlan->rgCacheActions[iPackageStartAction].packageStart.iPackageCompleteAction = pPlan->cCacheActions - 1;
+
+    // Create syncpoint action.
+    hr = AppendCacheAction(pPlan, &pCacheAction);
+    ExitOnFailure(hr, "Failed to append cache action.");
+
+    pCacheAction->type = BURN_CACHE_ACTION_TYPE_SIGNAL_SYNCPOINT;
+    pCacheAction->syncpoint.hEvent = ::CreateEventW(NULL, TRUE, FALSE, NULL);
+    ExitOnNullWithLastError(pCacheAction->syncpoint.hEvent, hr, "Failed to create syncpoint event.");
+
+    *phSyncpointEvent = pCacheAction->syncpoint.hEvent;
+
+    ++pPlan->cOverallProgressTicksTotal;
+
+    // If the package was not already fully cached then note that we planned the cache here. Otherwise, we only
+    // did cache operations to verify the cache is valid so we did not plan the acquisition of the package.
+    pPackage->fAcquire = (BURN_CACHE_STATE_COMPLETE != pPackage->cache);
+
+LExit:
+    return hr;
+}
+
+static HRESULT AddCacheSlipstreamMsps(
+    __in BURN_PLAN* pPlan,
+    __in BURN_PACKAGE* pPackage
+    )
+{
+    HRESULT hr = S_OK;
+    HANDLE hIgnored = NULL;
+
+    AssertSz(BURN_PACKAGE_TYPE_MSI == pPackage->type, "Only MSI packages can have slipstream patches.");
+
+    for (DWORD i = 0; i < pPackage->Msi.cSlipstreamMspPackages; ++i)
+    {
+        BURN_PACKAGE* pMspPackage = pPackage->Msi.rgpSlipstreamMspPackages[i];
+        AssertSz(BURN_PACKAGE_TYPE_MSP == pMspPackage->type, "Only MSP packages can be slipstream patches.");
+
+        hr = AddCachePackageHelper(pPlan, pMspPackage, &hIgnored);
+        ExitOnFailure(hr, "Failed to plan slipstream MSP: %ls", pMspPackage->sczId);
+    }
+
+LExit:
+    return hr;
+}
+
+static BOOL AlreadyPlannedCachePackage(
+    __in BURN_PLAN* pPlan,
+    __in_z LPCWSTR wzPackageId,
+    __out HANDLE* phSyncpointEvent
+    )
+{
+    BOOL fPlanned = FALSE;
+
+    for (DWORD iCacheAction = 0; iCacheAction < pPlan->cCacheActions; ++iCacheAction)
+    {
+        BURN_CACHE_ACTION* pCacheAction = pPlan->rgCacheActions + iCacheAction;
+
+        if (BURN_CACHE_ACTION_TYPE_PACKAGE_STOP == pCacheAction->type)
+        {
+            if (CSTR_EQUAL == ::CompareStringW(LOCALE_NEUTRAL, 0, pCacheAction->packageStop.pPackage->sczId, -1, wzPackageId, -1))
+            {
+                if (iCacheAction + 1 < pPlan->cCacheActions && BURN_CACHE_ACTION_TYPE_SIGNAL_SYNCPOINT == pPlan->rgCacheActions[iCacheAction + 1].type)
+                {
+                    *phSyncpointEvent = pPlan->rgCacheActions[iCacheAction + 1].syncpoint.hEvent;
+                }
+
+                fPlanned = TRUE;
+                break;
+            }
+        }
+    }
+
+    return fPlanned;
+}
+
+static DWORD GetNextCheckpointId()
+{
+    static DWORD dwCounter = 0;
+    return ++dwCounter;
+}
+
+static HRESULT AppendCacheAction(
+    __in BURN_PLAN* pPlan,
+    __out BURN_CACHE_ACTION** ppCacheAction
+    )
+{
+    HRESULT hr = S_OK;
+
+    hr = MemEnsureArraySize(reinterpret_cast<LPVOID*>(&pPlan->rgCacheActions), pPlan->cCacheActions + 1, sizeof(BURN_CACHE_ACTION), 5);
+    ExitOnFailure(hr, "Failed to grow plan's array of cache actions.");
+
+    *ppCacheAction = pPlan->rgCacheActions + pPlan->cCacheActions;
+    ++pPlan->cCacheActions;
+
+LExit:
+    return hr;
+}
+
+static HRESULT AppendRollbackCacheAction(
+    __in BURN_PLAN* pPlan,
+    __out BURN_CACHE_ACTION** ppCacheAction
+    )
+{
+    HRESULT hr = S_OK;
+
+    hr = MemEnsureArraySize(reinterpret_cast<LPVOID*>(&pPlan->rgRollbackCacheActions), pPlan->cRollbackCacheActions + 1, sizeof(BURN_CACHE_ACTION), 5);
+    ExitOnFailure(hr, "Failed to grow plan's array of rollback cache actions.");
+
+    *ppCacheAction = pPlan->rgRollbackCacheActions + pPlan->cRollbackCacheActions;
+    ++pPlan->cRollbackCacheActions;
+
+LExit:
+    return hr;
+}
+
+static HRESULT AppendLayoutContainerAction(
+    __in BURN_PLAN* pPlan,
+    __in_opt BURN_PACKAGE* pPackage,
+    __in DWORD iPackageStartAction,
+    __in BURN_CONTAINER* pContainer,
+    __in BOOL fContainerCached,
+    __in_z LPCWSTR wzLayoutDirectory
+    )
+{
+    HRESULT hr = S_OK;
+    BURN_CACHE_ACTION* pAcquireAction = NULL;
+    DWORD iAcquireAction = BURN_PLAN_INVALID_ACTION_INDEX;
+    LPWSTR sczContainerWorkingPath = NULL;
+    BURN_CACHE_ACTION* pCacheAction = NULL;
+    BURN_CACHE_CONTAINER_PROGRESS* pContainerProgress = NULL;
+
+    // No need to do anything if the container is already cached or is attached to the bundle (since the
+    // bundle itself will already have a layout action).
+    if (fContainerCached || pContainer->fAttached)
+    {
+        ExitFunction();
+    }
+
+    // Ensure the container is being acquired.  If it is, then some earlier package already planned the layout of this container so
+    // don't do it again. Otherwise, plan away!
+    if (!FindContainerCacheAction(BURN_CACHE_ACTION_TYPE_ACQUIRE_CONTAINER, pPlan, pContainer, 0, iPackageStartAction, NULL, NULL))
+    {
+        hr = AddAcquireContainer(pPlan, pContainer, &pAcquireAction, &iAcquireAction);
+        ExitOnFailure(hr, "Failed to append acquire container action for layout to plan.");
+
+        Assert(BURN_CACHE_ACTION_TYPE_ACQUIRE_CONTAINER == pAcquireAction->type);
+
+        // Create the layout container action.
+        hr = StrAllocString(&sczContainerWorkingPath, pAcquireAction->resolveContainer.sczUnverifiedPath, 0);
+        ExitOnFailure(hr, "Failed to copy container working path for layout.");
+
+        hr = AppendCacheAction(pPlan, &pCacheAction);
+        ExitOnFailure(hr, "Failed to append cache action to cache payload.");
+
+        hr = CreateContainerProgress(pPlan, pContainer, &pContainerProgress);
+        ExitOnFailure(hr, "Failed to create container progress.");
+
+        hr = StrAllocString(&pCacheAction->layoutContainer.sczLayoutDirectory, wzLayoutDirectory, 0);
+        ExitOnFailure(hr, "Failed to copy layout directory into plan.");
+
+        pCacheAction->type = BURN_CACHE_ACTION_TYPE_LAYOUT_CONTAINER;
+        pCacheAction->layoutContainer.pPackage = pPackage;
+        pCacheAction->layoutContainer.pContainer = pContainer;
+        pCacheAction->layoutContainer.iProgress = pContainerProgress->iIndex;
+        pCacheAction->layoutContainer.fMove = TRUE;
+        pCacheAction->layoutContainer.iTryAgainAction = iAcquireAction;
+        pCacheAction->layoutContainer.sczUnverifiedPath = sczContainerWorkingPath;
+        sczContainerWorkingPath = NULL;
+    }
+
+LExit:
+    ReleaseNullStr(sczContainerWorkingPath);
+
+    return hr;
+}
+
+static HRESULT AppendCacheOrLayoutPayloadAction(
+    __in BURN_PLAN* pPlan,
+    __in_opt BURN_PACKAGE* pPackage,
+    __in DWORD iPackageStartAction,
+    __in BURN_PAYLOAD* pPayload,
+    __in BOOL fPayloadCached,
+    __in_z_opt LPCWSTR wzLayoutDirectory
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR sczPayloadWorkingPath = NULL;
+    BURN_CACHE_ACTION* pCacheAction = NULL;
+    DWORD iTryAgainAction = BURN_PLAN_INVALID_ACTION_INDEX;
+    BURN_CACHE_PAYLOAD_PROGRESS* pPayloadProgress = NULL;
+
+    hr = CacheCalculatePayloadWorkingPath(pPlan->wzBundleId, pPayload, &sczPayloadWorkingPath);
+    ExitOnFailure(hr, "Failed to calculate unverified path for payload.");
+
+    // If the payload is in a container, ensure the container is being acquired
+    // then add this payload to the list of payloads to extract already in the plan.
+    if (pPayload->pContainer)
+    {
+        BURN_CACHE_ACTION* pPreviousPackageExtractAction = NULL;
+        BURN_CACHE_ACTION* pThisPackageExtractAction = NULL;
+
+        // If the payload is not already cached, then add it to the first extract container action in the plan. Extracting
+        // all the needed payloads from the container in a single pass is the most efficient way to extract files from
+        // containers. If there is not an extract container action before our package, that is okay because we'll create
+        // an extract container action for our package in a second anyway.
+        if (!fPayloadCached)
+        {
+            if (FindContainerCacheAction(BURN_CACHE_ACTION_TYPE_EXTRACT_CONTAINER, pPlan, pPayload->pContainer, 0, iPackageStartAction, &pPreviousPackageExtractAction, NULL))
+            {
+                hr = AddExtractPayload(pPreviousPackageExtractAction, pPackage, pPayload, sczPayloadWorkingPath);
+                ExitOnFailure(hr, "Failed to add extract payload action to previous package.");
+            }
+        }
+
+        // If there is already an extract container action after our package start action then try to find an acquire action
+        // that is matched with it. If there is an acquire action then that is our "try again" action, otherwise we'll use the existing
+        // extract action as the "try again" action.
+        if (FindContainerCacheAction(BURN_CACHE_ACTION_TYPE_EXTRACT_CONTAINER, pPlan, pPayload->pContainer, iPackageStartAction, BURN_PLAN_INVALID_ACTION_INDEX, &pThisPackageExtractAction, &iTryAgainAction))
+        {
+            DWORD iAcquireAction = BURN_PLAN_INVALID_ACTION_INDEX;
+            if (FindContainerCacheAction(BURN_CACHE_ACTION_TYPE_ACQUIRE_CONTAINER, pPlan, pPayload->pContainer, iPackageStartAction, iTryAgainAction, NULL, &iAcquireAction))
+            {
+                iTryAgainAction = iAcquireAction;
+            }
+        }
+        else // did not find an extract container action for our package.
+        {
+            // Ensure there is an extract action (and maybe an acquire action) for every package that has payloads. The
+            // acquire and extract action will be skipped if the payload is already cached or was added to a previous
+            // package's extract action above.
+            //
+            // These actions always exist (even when they are likely to be skipped) so that "try again" will not
+            // jump so far back in the plan that you end up extracting payloads for other packages. With these actions
+            // "try again" will only retry the extraction for payloads in this package.
+            hr = CreateContainerAcquireAndExtractAction(pPlan, pPayload->pContainer, iPackageStartAction, pPreviousPackageExtractAction ? TRUE : fPayloadCached, &pThisPackageExtractAction, &iTryAgainAction);
+            ExitOnFailure(hr, "Failed to create container extract action.");
+        }
+        ExitOnFailure(hr, "Failed while searching for package's container extract action.");
+
+        // We *always* add the payload to this package's extract action even though the extract action
+        // is probably being skipped until retry if there was a previous package extract action.
+        hr = AddExtractPayload(pThisPackageExtractAction, pPackage, pPayload, sczPayloadWorkingPath);
+        ExitOnFailure(hr, "Failed to add extract payload to current package.");
+    }
+    else // add a payload acquire action to the plan.
+    {
+        // Try to find an existing acquire action for this payload. If one is not found,
+        // we'll create it. At the same time we will change any cache/layout payload actions
+        // that would "MOVE" the file to "COPY" so that our new cache/layout action below
+        // can do the move.
+        pCacheAction = ProcessSharedPayload(pPlan, pPayload);
+        if (!pCacheAction)
+        {
+            hr = AppendCacheAction(pPlan, &pCacheAction);
+            ExitOnFailure(hr, "Failed to append cache action to acquire payload.");
+
+            pCacheAction->type = BURN_CACHE_ACTION_TYPE_ACQUIRE_PAYLOAD;
+            pCacheAction->fSkipUntilRetried = fPayloadCached;
+            pCacheAction->resolvePayload.pPackage = pPackage;
+            pCacheAction->resolvePayload.pPayload = pPayload;
+            hr = StrAllocString(&pCacheAction->resolvePayload.sczUnverifiedPath, sczPayloadWorkingPath, 0);
+            ExitOnFailure(hr, "Failed to copy unverified path for payload to acquire.");
+        }
+
+        iTryAgainAction = static_cast<DWORD>(pCacheAction - pPlan->rgCacheActions);
+        pCacheAction = NULL;
+    }
+
+    Assert(BURN_PLAN_INVALID_ACTION_INDEX != iTryAgainAction);
+    Assert(BURN_CACHE_ACTION_TYPE_ACQUIRE_CONTAINER == pPlan->rgCacheActions[iTryAgainAction].type ||
+           BURN_CACHE_ACTION_TYPE_EXTRACT_CONTAINER == pPlan->rgCacheActions[iTryAgainAction].type ||
+           BURN_CACHE_ACTION_TYPE_ACQUIRE_PAYLOAD == pPlan->rgCacheActions[iTryAgainAction].type);
+
+    hr = AppendCacheAction(pPlan, &pCacheAction);
+    ExitOnFailure(hr, "Failed to append cache action to cache payload.");
+
+    hr = CreatePayloadProgress(pPlan, pPayload, &pPayloadProgress);
+    ExitOnFailure(hr, "Failed to create payload progress.");
+
+    if (!wzLayoutDirectory)
+    {
+        pCacheAction->type = BURN_CACHE_ACTION_TYPE_CACHE_PAYLOAD;
+        pCacheAction->cachePayload.pPackage = pPackage;
+        pCacheAction->cachePayload.pPayload = pPayload;
+        pCacheAction->cachePayload.iProgress = pPayloadProgress->iIndex;
+        pCacheAction->cachePayload.fMove = TRUE;
+        pCacheAction->cachePayload.iTryAgainAction = iTryAgainAction;
+        pCacheAction->cachePayload.sczUnverifiedPath = sczPayloadWorkingPath;
+        sczPayloadWorkingPath = NULL;
+    }
+    else
+    {
+        hr = StrAllocString(&pCacheAction->layoutPayload.sczLayoutDirectory, wzLayoutDirectory, 0);
+        ExitOnFailure(hr, "Failed to copy layout directory into plan.");
+
+        pCacheAction->type = BURN_CACHE_ACTION_TYPE_LAYOUT_PAYLOAD;
+        pCacheAction->layoutPayload.pPackage = pPackage;
+        pCacheAction->layoutPayload.pPayload = pPayload;
+        pCacheAction->layoutPayload.iProgress = pPayloadProgress->iIndex;
+        pCacheAction->layoutPayload.fMove = TRUE;
+        pCacheAction->layoutPayload.iTryAgainAction = iTryAgainAction;
+        pCacheAction->layoutPayload.sczUnverifiedPath = sczPayloadWorkingPath;
+        sczPayloadWorkingPath = NULL;
+    }
+
+    pCacheAction = NULL;
+
+LExit:
+    ReleaseStr(sczPayloadWorkingPath);
+
+    return hr;
+}
+
+static BOOL FindContainerCacheAction(
+    __in BURN_CACHE_ACTION_TYPE type,
+    __in BURN_PLAN* pPlan,
+    __in BURN_CONTAINER* pContainer,
+    __in DWORD iSearchStart,
+    __in DWORD iSearchEnd,
+    __out_opt BURN_CACHE_ACTION** ppCacheAction,
+    __out_opt DWORD* piCacheAction
+    )
+{
+    BOOL fFound = FALSE; // assume we won't find what we are looking for.
+
+    Assert(BURN_CACHE_ACTION_TYPE_ACQUIRE_CONTAINER == type || BURN_CACHE_ACTION_TYPE_EXTRACT_CONTAINER == type);
+
+    iSearchStart = (BURN_PLAN_INVALID_ACTION_INDEX == iSearchStart) ? 0 : iSearchStart;
+    iSearchEnd = (BURN_PLAN_INVALID_ACTION_INDEX == iSearchEnd) ? pPlan->cCacheActions : iSearchEnd;
+
+    for (DWORD iSearch = iSearchStart; iSearch < iSearchEnd; ++iSearch)
+    {
+        BURN_CACHE_ACTION* pCacheAction = pPlan->rgCacheActions + iSearch;
+        if (pCacheAction->type == type &&
+            ((BURN_CACHE_ACTION_TYPE_ACQUIRE_CONTAINER == pCacheAction->type && pCacheAction->resolveContainer.pContainer == pContainer) ||
+             (BURN_CACHE_ACTION_TYPE_EXTRACT_CONTAINER == pCacheAction->type && pCacheAction->extractContainer.pContainer == pContainer)))
+        {
+            if (ppCacheAction)
+            {
+                *ppCacheAction = pCacheAction;
+            }
+
+            if (piCacheAction)
+            {
+                *piCacheAction = iSearch;
+            }
+
+            fFound = TRUE;
+            break;
+        }
+    }
+
+    return fFound;
+}
+
+static HRESULT CreateContainerAcquireAndExtractAction(
+    __in BURN_PLAN* pPlan,
+    __in BURN_CONTAINER* pContainer,
+    __in DWORD iPackageStartAction,
+    __in BOOL fPayloadCached,
+    __out BURN_CACHE_ACTION** ppContainerExtractAction,
+    __out DWORD* piContainerTryAgainAction
+    )
+{
+    HRESULT hr = S_OK;
+    DWORD iAcquireAction = BURN_PLAN_INVALID_ACTION_INDEX;
+    BURN_CACHE_ACTION* pContainerExtractAction = NULL;
+    DWORD iExtractAction = BURN_PLAN_INVALID_ACTION_INDEX;
+    DWORD iTryAgainAction = BURN_PLAN_INVALID_ACTION_INDEX;
+    LPWSTR sczContainerWorkingPath = NULL;
+
+    // If the container is actually attached to the executable then we will not need an acquire
+    // container action.
+    if (!pContainer->fActuallyAttached)
+    {
+        BURN_CACHE_ACTION* pAcquireContainerAction = NULL;
+
+        // If there is no plan to acquire the container then add acquire action since we
+        // can't extract stuff out of a container until we acquire the container.
+        if (!FindContainerCacheAction(BURN_CACHE_ACTION_TYPE_ACQUIRE_CONTAINER, pPlan, pContainer, iPackageStartAction, BURN_PLAN_INVALID_ACTION_INDEX, &pAcquireContainerAction, &iAcquireAction))
+        {
+            hr = AddAcquireContainer(pPlan, pContainer, &pAcquireContainerAction, &iAcquireAction);
+            ExitOnFailure(hr, "Failed to append acquire container action to plan.");
+
+            pAcquireContainerAction->fSkipUntilRetried = TRUE; // we'll start by assuming the acquire is not necessary and the fPayloadCached below will set us straight if wrong.
+        }
+
+        Assert(BURN_PLAN_INVALID_ACTION_INDEX != iAcquireAction);
+        Assert(BURN_CACHE_ACTION_TYPE_ACQUIRE_CONTAINER == pAcquireContainerAction->type);
+        Assert(pContainer == pAcquireContainerAction->resolveContainer.pContainer);
+    }
+
+    Assert((pContainer->fActuallyAttached && BURN_PLAN_INVALID_ACTION_INDEX == iAcquireAction) ||
+           (!pContainer->fActuallyAttached && BURN_PLAN_INVALID_ACTION_INDEX != iAcquireAction));
+
+    // If we do not find an action for extracting payloads from this container, create it now.
+    if (!FindContainerCacheAction(BURN_CACHE_ACTION_TYPE_EXTRACT_CONTAINER, pPlan, pContainer, (BURN_PLAN_INVALID_ACTION_INDEX == iAcquireAction) ? iPackageStartAction : iAcquireAction, BURN_PLAN_INVALID_ACTION_INDEX, &pContainerExtractAction, &iExtractAction))
+    {
+        // Attached containers that are actually attached use the executable path for their working path.
+        if (pContainer->fActuallyAttached)
+        {
+            Assert(BURN_PLAN_INVALID_ACTION_INDEX == iAcquireAction);
+
+            hr = PathForCurrentProcess(&sczContainerWorkingPath, NULL);
+            ExitOnFailure(hr, "Failed to get path for executing module as attached container working path.");
+        }
+        else // use the acquired working path as the location of the container.
+        {
+            Assert(BURN_PLAN_INVALID_ACTION_INDEX != iAcquireAction);
+
+            hr = StrAllocString(&sczContainerWorkingPath, pPlan->rgCacheActions[iAcquireAction].resolveContainer.sczUnverifiedPath, 0);
+            ExitOnFailure(hr, "Failed to copy container unverified path for cache action to extract container.");
+        }
+
+        hr = AppendCacheAction(pPlan, &pContainerExtractAction);
+        ExitOnFailure(hr, "Failed to append cache action to extract payloads from container.");
+
+        iExtractAction = pPlan->cCacheActions - 1;
+
+        pContainerExtractAction->type = BURN_CACHE_ACTION_TYPE_EXTRACT_CONTAINER;
+        pContainerExtractAction->fSkipUntilRetried = pContainer->fActuallyAttached; // assume we can skip the extract engine when the container is already attached and the fPayloadCached below will set us straight if wrong.
+        pContainerExtractAction->extractContainer.pContainer = pContainer;
+        pContainerExtractAction->extractContainer.iSkipUntilAcquiredByAction = iAcquireAction;
+        pContainerExtractAction->extractContainer.sczContainerUnverifiedPath = sczContainerWorkingPath;
+        sczContainerWorkingPath = NULL;
+    }
+
+    Assert(BURN_CACHE_ACTION_TYPE_EXTRACT_CONTAINER == pContainerExtractAction->type);
+    Assert(BURN_PLAN_INVALID_ACTION_INDEX != iExtractAction);
+
+    // If there is an acquire action, that is our try again action. Otherwise, we'll use the extract action.
+    iTryAgainAction = (BURN_PLAN_INVALID_ACTION_INDEX != iAcquireAction) ? iAcquireAction : iExtractAction;
+
+    // If the try again action thinks it can be skipped but the payload is not cached,
+    // ensure the action will not be skipped.
+    BURN_CACHE_ACTION* pTryAgainAction = pPlan->rgCacheActions + iTryAgainAction;
+    Assert((BURN_CACHE_ACTION_TYPE_ACQUIRE_CONTAINER == pTryAgainAction->type && pContainer == pTryAgainAction->resolveContainer.pContainer) ||
+           (BURN_CACHE_ACTION_TYPE_EXTRACT_CONTAINER == pTryAgainAction->type && pContainer == pTryAgainAction->extractContainer.pContainer));
+    if (pTryAgainAction->fSkipUntilRetried && !fPayloadCached)
+    {
+        pTryAgainAction->fSkipUntilRetried = FALSE;
+    }
+
+    *ppContainerExtractAction = pContainerExtractAction;
+    *piContainerTryAgainAction = iTryAgainAction;
+
+LExit:
+    ReleaseStr(sczContainerWorkingPath);
+
+    return hr;
+}
+
+static HRESULT AddAcquireContainer(
+    __in BURN_PLAN* pPlan,
+    __in BURN_CONTAINER* pContainer,
+    __out_opt BURN_CACHE_ACTION** ppCacheAction,
+    __out_opt DWORD* piCacheAction
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR sczContainerWorkingPath = NULL;
+    BURN_CACHE_ACTION* pAcquireContainerAction = NULL;
+    BURN_CACHE_CONTAINER_PROGRESS* pContainerProgress = NULL;
+
+    hr = CacheCalculateContainerWorkingPath(pPlan->wzBundleId, pContainer, &sczContainerWorkingPath);
+    ExitOnFailure(hr, "Failed to calculate unverified path for container.");
+
+    hr = AppendCacheAction(pPlan, &pAcquireContainerAction);
+    ExitOnFailure(hr, "Failed to append acquire container action to plan.");
+
+    hr = CreateContainerProgress(pPlan, pContainer, &pContainerProgress);
+    ExitOnFailure(hr, "Failed to create container progress.");
+
+    pAcquireContainerAction->type = BURN_CACHE_ACTION_TYPE_ACQUIRE_CONTAINER;
+    pAcquireContainerAction->resolveContainer.pContainer = pContainer;
+    pAcquireContainerAction->resolveContainer.iProgress = pContainerProgress->iIndex;
+    pAcquireContainerAction->resolveContainer.sczUnverifiedPath = sczContainerWorkingPath;
+    sczContainerWorkingPath = NULL;
+
+    if (ppCacheAction)
+    {
+        *ppCacheAction = pAcquireContainerAction;
+    }
+
+    if (piCacheAction)
+    {
+        *piCacheAction = pPlan->cCacheActions - 1;
+    }
+
+LExit:
+    ReleaseStr(sczContainerWorkingPath);
+
+    return hr;
+}
+
+static HRESULT AddExtractPayload(
+    __in BURN_CACHE_ACTION* pCacheAction,
+    __in_opt BURN_PACKAGE* pPackage,
+    __in BURN_PAYLOAD* pPayload,
+    __in_z LPCWSTR wzPayloadWorkingPath
+    )
+{
+    HRESULT hr = S_OK;
+
+    Assert(BURN_CACHE_ACTION_TYPE_EXTRACT_CONTAINER == pCacheAction->type);
+
+    hr = MemEnsureArraySize(reinterpret_cast<LPVOID*>(&pCacheAction->extractContainer.rgPayloads), pCacheAction->extractContainer.cPayloads + 1, sizeof(BURN_EXTRACT_PAYLOAD), 5);
+    ExitOnFailure(hr, "Failed to grow list of payloads to extract from container.");
+
+    BURN_EXTRACT_PAYLOAD* pExtractPayload = pCacheAction->extractContainer.rgPayloads + pCacheAction->extractContainer.cPayloads;
+    pExtractPayload->pPackage = pPackage;
+    pExtractPayload->pPayload = pPayload;
+    hr = StrAllocString(&pExtractPayload->sczUnverifiedPath, wzPayloadWorkingPath, 0);
+    ExitOnFailure(hr, "Failed to copy unverified path for payload to extract.");
+    ++pCacheAction->extractContainer.cPayloads;
+
+LExit:
+    return hr;
+}
+
+static BURN_CACHE_ACTION* ProcessSharedPayload(
+    __in BURN_PLAN* pPlan,
+    __in BURN_PAYLOAD* pPayload
+    )
+{
+    BURN_CACHE_ACTION* pAcquireAction = NULL;
+#ifdef DEBUG
+    DWORD cMove = 0;
+#endif
+
+    for (DWORD i = 0; i < pPlan->cCacheActions; ++i)
+    {
+        BURN_CACHE_ACTION* pCacheAction = pPlan->rgCacheActions + i;
+
+        if (BURN_CACHE_ACTION_TYPE_ACQUIRE_PAYLOAD == pCacheAction->type &&
+            pCacheAction->resolvePayload.pPayload == pPayload)
+        {
+            AssertSz(!pAcquireAction, "There should be at most one acquire cache action per payload.");
+            pAcquireAction = pCacheAction;
+        }
+        else if (BURN_CACHE_ACTION_TYPE_CACHE_PAYLOAD == pCacheAction->type &&
+                 pCacheAction->cachePayload.pPayload == pPayload &&
+                 pCacheAction->cachePayload.fMove)
+        {
+            // Since we found a shared payload, change its operation from MOVE to COPY.
+            pCacheAction->cachePayload.fMove = FALSE;
+
+            AssertSz(1 == ++cMove, "Shared payload should be moved once and only once.");
+#ifndef DEBUG
+            break;
+#endif
+        }
+        else if (BURN_CACHE_ACTION_TYPE_LAYOUT_PAYLOAD == pCacheAction->type &&
+                 pCacheAction->layoutPayload.pPayload == pPayload &&
+                 pCacheAction->layoutPayload.fMove)
+        {
+            // Since we found a shared payload, change its operation from MOVE to COPY if necessary
+            pCacheAction->layoutPayload.fMove = FALSE;
+
+            AssertSz(1 == ++cMove, "Shared payload should be moved once and only once.");
+#ifndef DEBUG
+            break;
+#endif
+        }
+    }
+
+    return pAcquireAction;
+}
+
+static HRESULT RemoveUnnecessaryActions(
+    __in BOOL fExecute,
+    __in BURN_EXECUTE_ACTION* rgActions,
+    __in DWORD cActions
+    )
+{
+    HRESULT hr = S_OK;
+    LPCSTR szExecuteOrRollback = fExecute ? "execute" : "rollback";
+
+    for (DWORD i = 0; i < cActions; ++i)
+    {
+        BURN_EXECUTE_ACTION* pAction = rgActions + i;
+
+        // If this MSP targets a package in the chain, check the target's execute state
+        // to see if this patch should be skipped.
+        if (BURN_EXECUTE_ACTION_TYPE_MSP_TARGET == pAction->type && pAction->mspTarget.pChainedTargetPackage)
+        {
+            BOOTSTRAPPER_ACTION_STATE chainedTargetPackageAction = fExecute ? pAction->mspTarget.pChainedTargetPackage->execute : pAction->mspTarget.pChainedTargetPackage->rollback;
+            if (BOOTSTRAPPER_ACTION_STATE_UNINSTALL == chainedTargetPackageAction)
+            {
+                LogId(REPORT_STANDARD, MSG_PLAN_SKIP_PATCH_ACTION, pAction->mspTarget.pPackage->sczId, LoggingActionStateToString(pAction->mspTarget.action), pAction->mspTarget.pChainedTargetPackage->sczId, LoggingActionStateToString(chainedTargetPackageAction), szExecuteOrRollback);
+                pAction->fDeleted = TRUE;
+            }
+            else if (BOOTSTRAPPER_ACTION_STATE_UNINSTALL < chainedTargetPackageAction && pAction->mspTarget.fSlipstream && BOOTSTRAPPER_ACTION_STATE_UNINSTALL < pAction->mspTarget.action)
+            {
+                // If the slipstream target is being installed or upgraded (not uninstalled or repaired) then we will slipstream so skip
+                // this action to install the patch standalone. Also, if the slipstream target is being repaired and the patch is being
+                // repaired, skip this operation since it will be redundant.
+                //
+                // The primary goal here is to ensure that a slipstream patch that is yet not installed is installed even if the MSI
+                // is already on the machine. The slipstream must be installed standalone if the MSI is being repaired.
+                if (BOOTSTRAPPER_ACTION_STATE_REPAIR != chainedTargetPackageAction || BOOTSTRAPPER_ACTION_STATE_REPAIR == pAction->mspTarget.action)
+                {
+                    LogId(REPORT_STANDARD, MSG_PLAN_SKIP_SLIPSTREAM_ACTION, pAction->mspTarget.pPackage->sczId, LoggingActionStateToString(pAction->mspTarget.action), pAction->mspTarget.pChainedTargetPackage->sczId, LoggingActionStateToString(chainedTargetPackageAction), szExecuteOrRollback);
+                    pAction->fDeleted = TRUE;
+                }
+            }
+        }
+    }
+
+    return hr;
+}
+
+static HRESULT FinalizeSlipstreamPatchActions(
+    __in BOOL fExecute,
+    __in BURN_EXECUTE_ACTION* rgActions,
+    __in DWORD cActions
+    )
+{
+    HRESULT hr = S_OK;
+
+    for (DWORD i = 0; i < cActions; ++i)
+    {
+        BURN_EXECUTE_ACTION* pAction = rgActions + i;
+
+        // If this MSI package contains slipstream patches store the slipstream actions.
+        if (BURN_EXECUTE_ACTION_TYPE_MSI_PACKAGE == pAction->type && pAction->msiPackage.pPackage->Msi.cSlipstreamMspPackages)
+        {
+            BURN_PACKAGE* pPackage = pAction->msiPackage.pPackage;
+
+            // By default all slipstream actions will be initialized to "no action" (aka: 0).
+            pAction->msiPackage.rgSlipstreamPatches = (BOOTSTRAPPER_ACTION_STATE*)MemAlloc(sizeof(BOOTSTRAPPER_ACTION_STATE) * pPackage->Msi.cSlipstreamMspPackages, TRUE);
+            ExitOnNull(pAction->msiPackage.rgSlipstreamPatches, hr, E_OUTOFMEMORY, "Failed to allocate memory for patch actions.");
+
+            // If we are uninstalling or repairing the MSI, we must ignore all the slipstream patches because they cannot
+            // be applied right now.
+            if (BOOTSTRAPPER_ACTION_STATE_REPAIR != pAction->msiPackage.action && BOOTSTRAPPER_ACTION_STATE_UNINSTALL != pAction->msiPackage.action)
+            {
+                for (DWORD j = 0; j < pPackage->Msi.cSlipstreamMspPackages; ++j)
+                {
+                    BURN_PACKAGE* pMspPackage = pPackage->Msi.rgpSlipstreamMspPackages[j];
+                    AssertSz(BURN_PACKAGE_TYPE_MSP == pMspPackage->type, "Only MSP packages can be slipstream patches.");
+
+                    pAction->msiPackage.rgSlipstreamPatches[j] = fExecute ? pMspPackage->execute : pMspPackage->rollback;
+                    for (DWORD k = 0; k < pMspPackage->Msp.cTargetProductCodes; ++k)
+                    {
+                        BURN_MSPTARGETPRODUCT* pTargetProduct = pMspPackage->Msp.rgTargetProducts + k;
+                        if (pPackage == pTargetProduct->pChainedTargetPackage)
+                        {
+                            pAction->msiPackage.rgSlipstreamPatches[j] = fExecute ? pTargetProduct->execute : pTargetProduct->rollback;
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+LExit:
+    return hr;
+}
+
+static HRESULT PlanDependencyActions(
+    __in BOOL fBundlePerMachine,
+    __in BURN_PLAN* pPlan,
+    __in BURN_PACKAGE* pPackage
+    )
+{
+    HRESULT hr = S_OK;
+
+    hr = DependencyPlanPackageBegin(fBundlePerMachine, pPackage, pPlan);
+    ExitOnFailure(hr, "Failed to begin plan dependency actions for package: %ls", pPackage->sczId);
+
+    hr = DependencyPlanPackage(NULL, pPackage, pPlan);
+    ExitOnFailure(hr, "Failed to plan package dependency actions.");
+
+    hr = DependencyPlanPackageComplete(pPackage, pPlan);
+    ExitOnFailure(hr, "Failed to complete plan dependency actions for package: %ls", pPackage->sczId);
+
+LExit:
+    return hr;
+}
+
+static HRESULT CalculateExecuteActions(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in BURN_PACKAGE* pPackage,
+    __in BURN_VARIABLES* pVariables,
+    __out_opt BOOL* pfBARequestedCache
+    )
+{
+    HRESULT hr = S_OK;
+
+    // Calculate execute actions.
+    switch (pPackage->type)
+    {
+    case BURN_PACKAGE_TYPE_EXE:
+        hr = ExeEnginePlanCalculatePackage(pPackage, pfBARequestedCache);
+        break;
+
+    case BURN_PACKAGE_TYPE_MSI:
+        hr = MsiEnginePlanCalculatePackage(pPackage, pVariables, pUserExperience, pfBARequestedCache);
+        break;
+
+    case BURN_PACKAGE_TYPE_MSP:
+        hr = MspEnginePlanCalculatePackage(pPackage, pUserExperience, pfBARequestedCache);
+        break;
+
+    case BURN_PACKAGE_TYPE_MSU:
+        hr = MsuEnginePlanCalculatePackage(pPackage, pfBARequestedCache);
+        break;
+
+    default:
+        hr = E_UNEXPECTED;
+        ExitOnFailure(hr, "Invalid package type.");
+    }
+
+LExit:
+    return hr;
+}
+
+static BOOL NeedsCache(
+    __in BURN_PLAN* pPlan,
+    __in BURN_PACKAGE* pPackage
+    )
+{
+    // All packages that have cacheType set to always should be cached if the bundle is going to be present.
+    if (BURN_CACHE_TYPE_ALWAYS == pPackage->cacheType && BOOTSTRAPPER_ACTION_INSTALL <= pPlan->action)
+    {
+        return TRUE;
+    }
+    else if (BURN_PACKAGE_TYPE_EXE == pPackage->type) // Exe packages require the package for all operations (even uninstall).
+    {
+        return BOOTSTRAPPER_ACTION_STATE_NONE != pPackage->execute;
+    }
+    else // The other package types can uninstall without the original package.
+    {
+        return BOOTSTRAPPER_ACTION_STATE_UNINSTALL < pPackage->execute;
+    }
+}
+
+static HRESULT CreateContainerProgress(
+    __in BURN_PLAN* pPlan,
+    __in BURN_CONTAINER* pContainer,
+    __out BURN_CACHE_CONTAINER_PROGRESS** ppContainerProgress
+    )
+{
+    HRESULT hr = S_OK;
+    BURN_CACHE_CONTAINER_PROGRESS* pContainerProgress = NULL;
+
+    hr = MemEnsureArraySize(reinterpret_cast<LPVOID*>(&pPlan->rgContainerProgress), pPlan->cContainerProgress + 1, sizeof(BURN_CACHE_CONTAINER_PROGRESS), 5);
+    ExitOnFailure(hr, "Failed to grow container progress list.");
+
+    if (!pPlan->shContainerProgress)
+    {
+        hr = DictCreateWithEmbeddedKey(&pPlan->shContainerProgress, 5, reinterpret_cast<void **>(&pPlan->rgContainerProgress), offsetof(BURN_CACHE_CONTAINER_PROGRESS, wzId), DICT_FLAG_NONE);
+        ExitOnFailure(hr, "Failed to create container progress dictionary.");
+    }
+
+    hr = DictGetValue(pPlan->shContainerProgress, pContainer->sczId, reinterpret_cast<void **>(&pContainerProgress));
+    if (E_NOTFOUND == hr)
+    {
+        pContainerProgress = &pPlan->rgContainerProgress[pPlan->cContainerProgress];
+        pContainerProgress->iIndex = pPlan->cContainerProgress;
+        pContainerProgress->pContainer = pContainer;
+        pContainerProgress->wzId = pContainer->sczId;
+
+        hr = DictAddValue(pPlan->shContainerProgress, pContainerProgress);
+        ExitOnFailure(hr, "Failed to add \"%ls\" to the container progress dictionary.", pContainerProgress->wzId);
+
+        ++pPlan->cContainerProgress;
+        pPlan->qwCacheSizeTotal += pContainer->qwFileSize;
+    }
+    ExitOnFailure(hr, "Failed to retrieve \"%ls\" from the container progress dictionary.", pContainer->sczId);
+
+    *ppContainerProgress = pContainerProgress;
+
+LExit:
+    return hr;
+}
+
+static HRESULT CreatePayloadProgress(
+    __in BURN_PLAN* pPlan,
+    __in BURN_PAYLOAD* pPayload,
+    __out BURN_CACHE_PAYLOAD_PROGRESS** ppPayloadProgress
+    )
+{
+    HRESULT hr = S_OK;
+    BURN_CACHE_PAYLOAD_PROGRESS* pPayloadProgress = NULL;
+
+    hr = MemEnsureArraySize(reinterpret_cast<LPVOID*>(&pPlan->rgPayloadProgress), pPlan->cPayloadProgress + 1, sizeof(BURN_CACHE_PAYLOAD_PROGRESS), 5);
+    ExitOnFailure(hr, "Failed to grow payload progress list.");
+
+    if (!pPlan->shPayloadProgress)
+    {
+        hr = DictCreateWithEmbeddedKey(&pPlan->shPayloadProgress, 5, reinterpret_cast<void **>(&pPlan->rgPayloadProgress), offsetof(BURN_CACHE_PAYLOAD_PROGRESS, wzId), DICT_FLAG_NONE);
+        ExitOnFailure(hr, "Failed to create payload progress dictionary.");
+    }
+
+    hr = DictGetValue(pPlan->shPayloadProgress, pPayload->sczKey, reinterpret_cast<void **>(&pPayloadProgress));
+    if (E_NOTFOUND == hr)
+    {
+        pPayloadProgress = &pPlan->rgPayloadProgress[pPlan->cPayloadProgress];
+        pPayloadProgress->iIndex = pPlan->cPayloadProgress;
+        pPayloadProgress->pPayload = pPayload;
+        pPayloadProgress->wzId = pPayload->sczKey;
+
+        hr = DictAddValue(pPlan->shPayloadProgress, pPayloadProgress);
+        ExitOnFailure(hr, "Failed to add \"%ls\" to the payload progress dictionary.", pPayloadProgress->wzId);
+
+        ++pPlan->cPayloadProgress;
+        pPlan->qwCacheSizeTotal += pPayload->qwFileSize;
+    }
+    ExitOnFailure(hr, "Failed to retrieve \"%ls\" from the payload progress dictionary.", pPayload->sczKey);
+
+    *ppPayloadProgress = pPayloadProgress;
+
+LExit:
+    return hr;
+}
+
+
+#ifdef DEBUG
+
+static void CacheActionLog(
+    __in DWORD iAction,
+    __in BURN_CACHE_ACTION* pAction,
+    __in BOOL fRollback
+    )
+{
+    LPCWSTR wzBase = fRollback ? L"   Rollback cache" : L"   Cache";
+    switch (pAction->type)
+    {
+    case BURN_CACHE_ACTION_TYPE_ACQUIRE_CONTAINER:
+        LogStringLine(REPORT_STANDARD, "%ls action[%u]: ACQUIRE_CONTAINER id: %ls, source path: %ls, working path: %ls, skip until retried: %hs", wzBase, iAction, pAction->resolveContainer.pContainer->sczId, pAction->resolveContainer.pContainer->sczSourcePath, pAction->resolveContainer.sczUnverifiedPath, LoggingBoolToString(pAction->fSkipUntilRetried));
+        break;
+
+    case BURN_CACHE_ACTION_TYPE_ACQUIRE_PAYLOAD:
+        LogStringLine(REPORT_STANDARD, "%ls action[%u]: ACQUIRE_PAYLOAD package id: %ls, payload id: %ls, source path: %ls, working path: %ls, skip until retried: %hs", wzBase, iAction, pAction->resolvePayload.pPackage ? pAction->resolvePayload.pPackage->sczId : L"", pAction->resolvePayload.pPayload->sczKey, pAction->resolvePayload.pPayload->sczSourcePath, pAction->resolvePayload.sczUnverifiedPath, LoggingBoolToString(pAction->fSkipUntilRetried));
+        break;
+
+    case BURN_CACHE_ACTION_TYPE_CACHE_PAYLOAD:
+        LogStringLine(REPORT_STANDARD, "%ls action[%u]: CACHE_PAYLOAD package id: %ls, payload id: %ls, working path: %ls, operation: %ls, skip until retried: %hs, retry action: %u", wzBase, iAction, pAction->cachePayload.pPackage->sczId, pAction->cachePayload.pPayload->sczKey, pAction->cachePayload.sczUnverifiedPath, pAction->cachePayload.fMove ? L"move" : L"copy", LoggingBoolToString(pAction->fSkipUntilRetried), pAction->cachePayload.iTryAgainAction);
+        break;
+
+    case BURN_CACHE_ACTION_TYPE_CHECKPOINT:
+        LogStringLine(REPORT_STANDARD, "%ls action[%u]: CHECKPOINT id: %u", wzBase, iAction, pAction->checkpoint.dwId);
+        break;
+
+    case BURN_CACHE_ACTION_TYPE_EXTRACT_CONTAINER:
+        LogStringLine(REPORT_STANDARD, "%ls action[%u]: EXTRACT_CONTAINER id: %ls, working path: %ls, skip until retried: %hs, skip until acquired by action: %u", wzBase, iAction, pAction->extractContainer.pContainer->sczId, pAction->extractContainer.sczContainerUnverifiedPath, LoggingBoolToString(pAction->fSkipUntilRetried), pAction->extractContainer.iSkipUntilAcquiredByAction);
+        for (DWORD j = 0; j < pAction->extractContainer.cPayloads; j++)
+        {
+            LogStringLine(REPORT_STANDARD, "      extract package id: %ls, payload id: %ls, working path: %ls", pAction->extractContainer.rgPayloads[j].pPackage->sczId, pAction->extractContainer.rgPayloads[j].pPayload->sczKey, pAction->extractContainer.rgPayloads[j].sczUnverifiedPath);
+        }
+        break;
+
+    case BURN_CACHE_ACTION_TYPE_LAYOUT_BUNDLE:
+        LogStringLine(REPORT_STANDARD, "%ls action[%u]: LAYOUT_BUNDLE working path: %ls, layout directory: %ls, exe name: %ls, skip until retried: %hs", wzBase, iAction, pAction->bundleLayout.sczUnverifiedPath, pAction->bundleLayout.sczLayoutDirectory, pAction->bundleLayout.sczExecutableName, LoggingBoolToString(pAction->fSkipUntilRetried));
+        break;
+
+    case BURN_CACHE_ACTION_TYPE_LAYOUT_CONTAINER:
+        LogStringLine(REPORT_STANDARD, "%ls action[%u]: LAYOUT_CONTAINER package id: %ls, container id: %ls, working path: %ls, layout directory: %ls, operation: %ls, skip until retried: %hs, retry action: %u", wzBase, iAction, pAction->layoutContainer.pPackage ? pAction->layoutContainer.pPackage->sczId : L"", pAction->layoutContainer.pContainer->sczId, pAction->layoutContainer.sczUnverifiedPath, pAction->layoutContainer.sczLayoutDirectory, pAction->layoutContainer.fMove ? L"move" : L"copy", LoggingBoolToString(pAction->fSkipUntilRetried), pAction->layoutContainer.iTryAgainAction);
+        break;
+
+    case BURN_CACHE_ACTION_TYPE_LAYOUT_PAYLOAD:
+        LogStringLine(REPORT_STANDARD, "%ls action[%u]: LAYOUT_PAYLOAD package id: %ls, payload id: %ls, working path: %ls, layout directory: %ls, operation: %ls, skip until retried: %hs, retry action: %u", wzBase, iAction, pAction->layoutPayload.pPackage ? pAction->layoutPayload.pPackage->sczId : L"", pAction->layoutPayload.pPayload->sczKey, pAction->layoutPayload.sczUnverifiedPath, pAction->layoutPayload.sczLayoutDirectory, pAction->layoutPayload.fMove ? L"move" : L"copy", LoggingBoolToString(pAction->fSkipUntilRetried), pAction->layoutPayload.iTryAgainAction);
+        break;
+
+    case BURN_CACHE_ACTION_TYPE_PACKAGE_START:
+        LogStringLine(REPORT_STANDARD, "%ls action[%u]: PACKAGE_START id: %ls, plan index for skip: %u, payloads to cache: %u, bytes to cache: %llu, skip until retried: %hs", wzBase, iAction, pAction->packageStart.pPackage->sczId, pAction->packageStart.iPackageCompleteAction, pAction->packageStart.cCachePayloads, pAction->packageStart.qwCachePayloadSizeTotal, LoggingBoolToString(pAction->fSkipUntilRetried));
+        break;
+
+    case BURN_CACHE_ACTION_TYPE_PACKAGE_STOP:
+        LogStringLine(REPORT_STANDARD, "%ls action[%u]: PACKAGE_STOP id: %ls, skip until retried: %hs", wzBase, iAction, pAction->packageStop.pPackage->sczId, LoggingBoolToString(pAction->fSkipUntilRetried));
+        break;
+
+    case BURN_CACHE_ACTION_TYPE_ROLLBACK_PACKAGE:
+        LogStringLine(REPORT_STANDARD, "%ls action[%u]: ROLLBACK_PACKAGE id: %ls, skip until retried: %hs", wzBase, iAction, pAction->rollbackPackage.pPackage->sczId, LoggingBoolToString(pAction->fSkipUntilRetried));
+        break;
+
+    case BURN_CACHE_ACTION_TYPE_SIGNAL_SYNCPOINT:
+        LogStringLine(REPORT_STANDARD, "%ls action[%u]: SIGNAL_SYNCPOINT event handle: 0x%x, skip until retried: %hs", wzBase, iAction, pAction->syncpoint.hEvent, LoggingBoolToString(pAction->fSkipUntilRetried));
+        break;
+
+    case BURN_CACHE_ACTION_TYPE_TRANSACTION_BOUNDARY:
+        LogStringLine(REPORT_STANDARD, "%ls action[%u]: TRANSACTION_BOUNDARY id: %ls, event handle: 0x%x, vital: %ls, transaction: %ls", wzBase, iAction, pAction->rollbackBoundary.pRollbackBoundary->sczId, pAction->rollbackBoundary.hEvent, pAction->rollbackBoundary.pRollbackBoundary->fVital ? L"yes" : L"no", pAction->rollbackBoundary.pRollbackBoundary->fTransaction ? L"yes" : L"no");
+        break;
+
+    default:
+        AssertSz(FALSE, "Unknown cache action type.");
+        break;
+    }
+}
+
+static void ExecuteActionLog(
+    __in DWORD iAction,
+    __in BURN_EXECUTE_ACTION* pAction,
+    __in BOOL fRollback
+    )
+{
+    LPCWSTR wzBase = fRollback ? L"   Rollback" : L"   Execute";
+    switch (pAction->type)
+    {
+    case BURN_EXECUTE_ACTION_TYPE_CHECKPOINT:
+        LogStringLine(REPORT_STANDARD, "%ls action[%u]: CHECKPOINT id: %u", wzBase, iAction, pAction->checkpoint.dwId);
+        break;
+
+    case BURN_EXECUTE_ACTION_TYPE_PACKAGE_PROVIDER:
+        LogStringLine(REPORT_STANDARD, "%ls action[%u]: PACKAGE_PROVIDER package id: %ls, action: %u", wzBase, iAction, pAction->packageProvider.pPackage->sczId, pAction->packageProvider.action);
+        break;
+
+    case BURN_EXECUTE_ACTION_TYPE_PACKAGE_DEPENDENCY:
+        LogStringLine(REPORT_STANDARD, "%ls action[%u]: PACKAGE_DEPENDENCY package id: %ls, bundle provider key: %ls, action: %u", wzBase, iAction, pAction->packageDependency.pPackage->sczId, pAction->packageDependency.sczBundleProviderKey, pAction->packageDependency.action);
+        break;
+
+    case BURN_EXECUTE_ACTION_TYPE_EXE_PACKAGE:
+        LogStringLine(REPORT_STANDARD, "%ls action[%u]: EXE_PACKAGE package id: %ls, action: %hs, ignore dependencies: %ls", wzBase, iAction, pAction->exePackage.pPackage->sczId, LoggingActionStateToString(pAction->exePackage.action), pAction->exePackage.sczIgnoreDependencies);
+        break;
+
+    case BURN_EXECUTE_ACTION_TYPE_MSI_PACKAGE:
+        LogStringLine(REPORT_STANDARD, "%ls action[%u]: MSI_PACKAGE package id: %ls, action: %hs, ui level: %u, log path: %ls, logging attrib: %u", wzBase, iAction, pAction->msiPackage.pPackage->sczId, LoggingActionStateToString(pAction->msiPackage.action), pAction->msiPackage.uiLevel, pAction->msiPackage.sczLogPath, pAction->msiPackage.dwLoggingAttributes);
+        for (DWORD j = 0; j < pAction->msiPackage.cPatches; ++j)
+        {
+            LogStringLine(REPORT_STANDARD, "      Patch[%u]: order: %u, msp package id: %ls", j, pAction->msiPackage.rgOrderedPatches->dwOrder, pAction->msiPackage.rgOrderedPatches[j].dwOrder, pAction->msiPackage.rgOrderedPatches[j].pPackage->sczId);
+        }
+        break;
+
+    case BURN_EXECUTE_ACTION_TYPE_MSP_TARGET:
+        LogStringLine(REPORT_STANDARD, "%ls action[%u]: MSP_TARGET package id: %ls, action: %hs, target product code: %ls, target per-machine: %ls, ui level: %u, log path: %ls", wzBase, iAction, pAction->mspTarget.pPackage->sczId, LoggingActionStateToString(pAction->mspTarget.action), pAction->mspTarget.sczTargetProductCode, pAction->mspTarget.fPerMachineTarget ? L"yes" : L"no", pAction->mspTarget.uiLevel, pAction->mspTarget.sczLogPath);
+        for (DWORD j = 0; j < pAction->mspTarget.cOrderedPatches; ++j)
+        {
+            LogStringLine(REPORT_STANDARD, "      Patch[%u]: order: %u, msp package id: %ls", j, pAction->mspTarget.rgOrderedPatches[j].dwOrder, pAction->mspTarget.rgOrderedPatches[j].pPackage->sczId);
+        }
+        break;
+
+    case BURN_EXECUTE_ACTION_TYPE_MSU_PACKAGE:
+        LogStringLine(REPORT_STANDARD, "%ls action[%u]: MSU_PACKAGE package id: %ls, action: %hs, log path: %ls", wzBase, iAction, pAction->msuPackage.pPackage->sczId, LoggingActionStateToString(pAction->msuPackage.action), pAction->msuPackage.sczLogPath);
+        break;
+
+    case BURN_EXECUTE_ACTION_TYPE_REGISTRATION:
+        LogStringLine(REPORT_STANDARD, "%ls action[%u]: REGISTRATION keep: %ls", wzBase, iAction, pAction->registration.fKeep ? L"yes" : L"no");
+        break;
+
+    case BURN_EXECUTE_ACTION_TYPE_ROLLBACK_BOUNDARY:
+        LogStringLine(REPORT_STANDARD, "%ls action[%u]: ROLLBACK_BOUNDARY id: %ls, vital: %ls", wzBase, iAction, pAction->rollbackBoundary.pRollbackBoundary->sczId, pAction->rollbackBoundary.pRollbackBoundary->fVital ? L"yes" : L"no");
+        break;
+
+    case BURN_EXECUTE_ACTION_TYPE_WAIT_SYNCPOINT:
+        LogStringLine(REPORT_STANDARD, "%ls action[%u]: WAIT_SYNCPOINT event handle: 0x%x", wzBase, iAction, pAction->syncpoint.hEvent);
+        break;
+
+    case BURN_EXECUTE_ACTION_TYPE_UNCACHE_PACKAGE:
+        LogStringLine(REPORT_STANDARD, "%ls action[%u]: UNCACHE_PACKAGE id: %ls", wzBase, iAction, pAction->uncachePackage.pPackage->sczId);
+        break;
+
+    case BURN_EXECUTE_ACTION_TYPE_COMPATIBLE_PACKAGE:
+        LogStringLine(REPORT_STANDARD, "%ls action[%u]: COMPATIBLE_PACKAGE reference id: %ls, installed ProductCode: %ls", wzBase, iAction, pAction->compatiblePackage.pReferencePackage->sczId, pAction->compatiblePackage.sczInstalledProductCode);
+        break;
+
+    default:
+        AssertSz(FALSE, "Unknown execute action type.");
+        break;
+    }
+}
+
+extern "C" void PlanDump(
+    __in BURN_PLAN* pPlan
+    )
+{
+    LogStringLine(REPORT_STANDARD, "--- Begin plan dump ---");
+
+    LogStringLine(REPORT_STANDARD, "Plan action: %hs", LoggingBurnActionToString(pPlan->action));
+    LogStringLine(REPORT_STANDARD, "     per-machine: %hs", LoggingTrueFalseToString(pPlan->fPerMachine));
+    LogStringLine(REPORT_STANDARD, "     keep registration by default: %hs", LoggingTrueFalseToString(pPlan->fKeepRegistrationDefault));
+    LogStringLine(REPORT_STANDARD, "     estimated size: %llu", pPlan->qwEstimatedSize);
+
+    LogStringLine(REPORT_STANDARD, "Plan cache size: %llu", pPlan->qwCacheSizeTotal);
+    for (DWORD i = 0; i < pPlan->cCacheActions; ++i)
+    {
+        CacheActionLog(i, pPlan->rgCacheActions + i, FALSE);
+    }
+
+    for (DWORD i = 0; i < pPlan->cRollbackCacheActions; ++i)
+    {
+        CacheActionLog(i, pPlan->rgRollbackCacheActions + i, TRUE);
+    }
+
+    LogStringLine(REPORT_STANDARD, "Plan execute package count: %u", pPlan->cExecutePackagesTotal);
+    LogStringLine(REPORT_STANDARD, "     overall progress ticks: %u", pPlan->cOverallProgressTicksTotal);
+    for (DWORD i = 0; i < pPlan->cExecuteActions; ++i)
+    {
+        ExecuteActionLog(i, pPlan->rgExecuteActions + i, FALSE);
+    }
+
+    for (DWORD i = 0; i < pPlan->cRollbackActions; ++i)
+    {
+        ExecuteActionLog(i, pPlan->rgRollbackActions + i, TRUE);
+    }
+
+    for (DWORD i = 0; i < pPlan->cCleanActions; ++i)
+    {
+        LogStringLine(REPORT_STANDARD, "   Clean action[%u]: CLEAN_PACKAGE package id: %ls", i, pPlan->rgCleanActions[i].pPackage->sczId);
+    }
+
+    for (DWORD i = 0; i < pPlan->cPlannedProviders; ++i)
+    {
+        LogStringLine(REPORT_STANDARD, "   Dependency action[%u]: PLANNED_PROVIDER key: %ls, name: %ls", i, pPlan->rgPlannedProviders[i].sczKey, pPlan->rgPlannedProviders[i].sczName);
+    }
+
+    LogStringLine(REPORT_STANDARD, "--- End plan dump ---");
+}
+
+#endif
diff --git a/src/engine/plan.h b/src/engine/plan.h
new file mode 100644
index 00000000..54cfe59d
--- /dev/null
+++ b/src/engine/plan.h
@@ -0,0 +1,543 @@
+#pragma once
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+
+// constants
+
+const DWORD BURN_PLAN_INVALID_ACTION_INDEX = 0x80000000;
+
+enum BURN_REGISTRATION_ACTION_OPERATIONS
+{
+    BURN_REGISTRATION_ACTION_OPERATIONS_NONE = 0x0,
+    BURN_REGISTRATION_ACTION_OPERATIONS_CACHE_BUNDLE = 0x1,
+    BURN_REGISTRATION_ACTION_OPERATIONS_WRITE_REGISTRATION = 0x2,
+    BURN_REGISTRATION_ACTION_OPERATIONS_UPDATE_SIZE = 0x4,
+};
+
+enum BURN_DEPENDENCY_REGISTRATION_ACTION
+{
+    BURN_DEPENDENCY_REGISTRATION_ACTION_NONE,
+    BURN_DEPENDENCY_REGISTRATION_ACTION_REGISTER,
+    BURN_DEPENDENCY_REGISTRATION_ACTION_UNREGISTER,
+};
+
+enum BURN_DEPENDENT_REGISTRATION_ACTION_TYPE
+{
+    BURN_DEPENDENT_REGISTRATION_ACTION_TYPE_NONE,
+    BURN_DEPENDENT_REGISTRATION_ACTION_TYPE_REGISTER,
+    BURN_DEPENDENT_REGISTRATION_ACTION_TYPE_UNREGISTER,
+};
+
+enum BURN_CACHE_ACTION_TYPE
+{
+    BURN_CACHE_ACTION_TYPE_NONE,
+    BURN_CACHE_ACTION_TYPE_CHECKPOINT,
+    BURN_CACHE_ACTION_TYPE_LAYOUT_BUNDLE,
+    BURN_CACHE_ACTION_TYPE_PACKAGE_START,
+    BURN_CACHE_ACTION_TYPE_PACKAGE_STOP,
+    BURN_CACHE_ACTION_TYPE_ROLLBACK_PACKAGE,
+    BURN_CACHE_ACTION_TYPE_SIGNAL_SYNCPOINT,
+    BURN_CACHE_ACTION_TYPE_ACQUIRE_CONTAINER,
+    BURN_CACHE_ACTION_TYPE_EXTRACT_CONTAINER,
+    BURN_CACHE_ACTION_TYPE_LAYOUT_CONTAINER,
+    BURN_CACHE_ACTION_TYPE_ACQUIRE_PAYLOAD,
+    BURN_CACHE_ACTION_TYPE_CACHE_PAYLOAD,
+    BURN_CACHE_ACTION_TYPE_LAYOUT_PAYLOAD,
+    BURN_CACHE_ACTION_TYPE_TRANSACTION_BOUNDARY,
+};
+
+enum BURN_EXECUTE_ACTION_TYPE
+{
+    BURN_EXECUTE_ACTION_TYPE_NONE,
+    BURN_EXECUTE_ACTION_TYPE_CHECKPOINT,
+    BURN_EXECUTE_ACTION_TYPE_WAIT_SYNCPOINT,
+    BURN_EXECUTE_ACTION_TYPE_UNCACHE_PACKAGE,
+    BURN_EXECUTE_ACTION_TYPE_EXE_PACKAGE,
+    BURN_EXECUTE_ACTION_TYPE_MSI_PACKAGE,
+    BURN_EXECUTE_ACTION_TYPE_MSP_TARGET,
+    BURN_EXECUTE_ACTION_TYPE_MSU_PACKAGE,
+    BURN_EXECUTE_ACTION_TYPE_SERVICE_STOP,
+    BURN_EXECUTE_ACTION_TYPE_SERVICE_START,
+    BURN_EXECUTE_ACTION_TYPE_PACKAGE_PROVIDER,
+    BURN_EXECUTE_ACTION_TYPE_PACKAGE_DEPENDENCY,
+    BURN_EXECUTE_ACTION_TYPE_ROLLBACK_BOUNDARY,
+    BURN_EXECUTE_ACTION_TYPE_REGISTRATION,
+    BURN_EXECUTE_ACTION_TYPE_COMPATIBLE_PACKAGE,
+};
+
+enum BURN_CLEAN_ACTION_TYPE
+{
+    BURN_CLEAN_ACTION_TYPE_NONE,
+    BURN_CLEAN_ACTION_TYPE_BUNDLE,
+    BURN_CLEAN_ACTION_TYPE_PACKAGE,
+};
+
+
+// structs
+
+typedef struct _BURN_EXTRACT_PAYLOAD
+{
+    BURN_PACKAGE* pPackage;
+    BURN_PAYLOAD* pPayload;
+    LPWSTR sczUnverifiedPath;
+} BURN_EXTRACT_PAYLOAD;
+
+typedef struct _BURN_DEPENDENT_REGISTRATION_ACTION
+{
+    BURN_DEPENDENT_REGISTRATION_ACTION_TYPE type;
+    LPWSTR sczBundleId;
+    LPWSTR sczDependentProviderKey;
+} BURN_DEPENDENT_REGISTRATION_ACTION;
+
+typedef struct _BURN_CACHE_CONTAINER_PROGRESS
+{
+    LPWSTR wzId;
+    DWORD iIndex;
+    BOOL fCachedDuringApply;
+    BURN_CONTAINER* pContainer;
+} BURN_CACHE_CONTAINER_PROGRESS;
+
+typedef struct _BURN_CACHE_PAYLOAD_PROGRESS
+{
+    LPWSTR wzId;
+    DWORD iIndex;
+    BOOL fCachedDuringApply;
+    BURN_PAYLOAD* pPayload;
+} BURN_CACHE_PAYLOAD_PROGRESS;
+
+typedef struct _BURN_CACHE_ACTION
+{
+    BURN_CACHE_ACTION_TYPE type;
+    BOOL fSkipUntilRetried;
+    union
+    {
+        struct
+        {
+            DWORD dwId;
+        } checkpoint;
+        struct
+        {
+            LPWSTR sczExecutableName;
+            LPWSTR sczLayoutDirectory;
+            LPWSTR sczUnverifiedPath;
+            DWORD64 qwBundleSize;
+        } bundleLayout;
+        struct
+        {
+            BURN_PACKAGE* pPackage;
+            DWORD cCachePayloads;
+            DWORD64 qwCachePayloadSizeTotal;
+            DWORD iPackageCompleteAction;
+        } packageStart;
+        struct
+        {
+            BURN_PACKAGE* pPackage;
+        } packageStop;
+        struct
+        {
+            BURN_PACKAGE* pPackage;
+        } rollbackPackage;
+        struct
+        {
+            HANDLE hEvent;
+        } syncpoint;
+        struct
+        {
+            BURN_CONTAINER* pContainer;
+            DWORD iProgress;
+            LPWSTR sczUnverifiedPath;
+        } resolveContainer;
+        struct
+        {
+            BURN_CONTAINER* pContainer;
+            DWORD iSkipUntilAcquiredByAction;
+            LPWSTR sczContainerUnverifiedPath;
+
+            BURN_EXTRACT_PAYLOAD* rgPayloads;
+            DWORD cPayloads;
+        } extractContainer;
+        struct
+        {
+            BURN_PACKAGE* pPackage;
+            BURN_CONTAINER* pContainer;
+            DWORD iProgress;
+            DWORD iTryAgainAction;
+            DWORD cTryAgainAttempts;
+            LPWSTR sczLayoutDirectory;
+            LPWSTR sczUnverifiedPath;
+            BOOL fMove;
+        } layoutContainer;
+        struct
+        {
+            BURN_PACKAGE* pPackage;
+            BURN_PAYLOAD* pPayload;
+            DWORD iProgress;
+            LPWSTR sczUnverifiedPath;
+        } resolvePayload;
+        struct
+        {
+            BURN_PACKAGE* pPackage;
+            BURN_PAYLOAD* pPayload;
+            DWORD iProgress;
+            DWORD iTryAgainAction;
+            DWORD cTryAgainAttempts;
+            LPWSTR sczUnverifiedPath;
+            BOOL fMove;
+        } cachePayload;
+        struct
+        {
+            BURN_PACKAGE* pPackage;
+            BURN_PAYLOAD* pPayload;
+            DWORD iProgress;
+            DWORD iTryAgainAction;
+            DWORD cTryAgainAttempts;
+            LPWSTR sczLayoutDirectory;
+            LPWSTR sczUnverifiedPath;
+            BOOL fMove;
+        } layoutPayload;
+        struct
+        {
+            BURN_ROLLBACK_BOUNDARY* pRollbackBoundary;
+            HANDLE hEvent;
+        } rollbackBoundary;
+    };
+} BURN_CACHE_ACTION;
+
+typedef struct _BURN_ORDERED_PATCHES
+{
+    DWORD dwOrder;
+    BURN_PACKAGE* pPackage;
+} BURN_ORDERED_PATCHES;
+
+typedef struct _BURN_EXECUTE_ACTION
+{
+    BURN_EXECUTE_ACTION_TYPE type;
+    BOOL fDeleted; // used to skip an action after it was planned since deleting actions out of the plan is too hard.
+    union
+    {
+        struct
+        {
+            DWORD dwId;
+        } checkpoint;
+        struct
+        {
+            HANDLE hEvent;
+        } syncpoint;
+        struct
+        {
+            BURN_PACKAGE* pPackage;
+        } uncachePackage;
+        struct
+        {
+            BURN_PACKAGE* pPackage;
+            BOOL fFireAndForget;
+            BOOTSTRAPPER_ACTION_STATE action;
+            LPWSTR sczIgnoreDependencies;
+            LPWSTR sczAncestors;
+        } exePackage;
+        struct
+        {
+            BURN_PACKAGE* pPackage;
+            LPWSTR sczLogPath;
+            DWORD dwLoggingAttributes;
+            INSTALLUILEVEL uiLevel;
+            BOOTSTRAPPER_ACTION_STATE action;
+
+            BOOTSTRAPPER_FEATURE_ACTION* rgFeatures;
+            BOOTSTRAPPER_ACTION_STATE* rgSlipstreamPatches;
+
+            BURN_ORDERED_PATCHES* rgOrderedPatches;
+            DWORD cPatches;
+        } msiPackage;
+        struct
+        {
+            BURN_PACKAGE* pPackage;
+            LPWSTR sczTargetProductCode;
+            BURN_PACKAGE* pChainedTargetPackage;
+            BOOL fSlipstream;
+            BOOL fPerMachineTarget;
+            LPWSTR sczLogPath;
+            INSTALLUILEVEL uiLevel;
+            BOOTSTRAPPER_ACTION_STATE action;
+
+            BURN_ORDERED_PATCHES* rgOrderedPatches;
+            DWORD cOrderedPatches;
+        } mspTarget;
+        struct
+        {
+            BURN_PACKAGE* pPackage;
+            LPWSTR sczLogPath;
+            BOOTSTRAPPER_ACTION_STATE action;
+        } msuPackage;
+        struct
+        {
+            LPWSTR sczServiceName;
+        } service;
+        struct
+        {
+            BOOL fKeep;
+        } registration;
+        struct
+        {
+            BURN_ROLLBACK_BOUNDARY* pRollbackBoundary;
+        } rollbackBoundary;
+        struct
+        {
+            BURN_PACKAGE* pPackage;
+            BURN_DEPENDENCY_ACTION action;
+        } packageProvider;
+        struct
+        {
+            BURN_PACKAGE* pPackage;
+            LPWSTR sczBundleProviderKey;
+            BURN_DEPENDENCY_ACTION action;
+        } packageDependency;
+        struct
+        {
+            BURN_PACKAGE* pReferencePackage;
+            LPWSTR sczInstalledProductCode;
+            DWORD64 qwInstalledVersion;
+        } compatiblePackage;
+    };
+} BURN_EXECUTE_ACTION;
+
+typedef struct _BURN_CLEAN_ACTION
+{
+    BURN_PACKAGE* pPackage;
+} BURN_CLEAN_ACTION;
+
+typedef struct _BURN_PLAN
+{
+    BOOTSTRAPPER_ACTION action;
+    LPWSTR wzBundleId;          // points directly into parent the ENGINE_STATE.
+    LPWSTR wzBundleProviderKey; // points directly into parent the ENGINE_STATE.
+    BOOL fPerMachine;
+    BOOL fRegister;
+    DWORD dwRegistrationOperations;
+    BOOL fKeepRegistrationDefault;
+    BOOL fDisallowRemoval;
+
+    DWORD64 qwCacheSizeTotal;
+
+    DWORD64 qwEstimatedSize;
+
+    DWORD cExecutePackagesTotal;
+    DWORD cOverallProgressTicksTotal;
+
+    BURN_DEPENDENCY_REGISTRATION_ACTION dependencyRegistrationAction;
+
+    BURN_DEPENDENT_REGISTRATION_ACTION* rgRegistrationActions;
+    DWORD cRegistrationActions;
+
+    BURN_DEPENDENT_REGISTRATION_ACTION* rgRollbackRegistrationActions;
+    DWORD cRollbackRegistrationActions;
+
+    BURN_CACHE_ACTION* rgCacheActions;
+    DWORD cCacheActions;
+
+    BURN_CACHE_ACTION* rgRollbackCacheActions;
+    DWORD cRollbackCacheActions;
+
+    BURN_EXECUTE_ACTION* rgExecuteActions;
+    DWORD cExecuteActions;
+
+    BURN_EXECUTE_ACTION* rgRollbackActions;
+    DWORD cRollbackActions;
+
+    BURN_CLEAN_ACTION* rgCleanActions;
+    DWORD cCleanActions;
+
+    DEPENDENCY* rgPlannedProviders;
+    UINT cPlannedProviders;
+
+    BURN_CACHE_CONTAINER_PROGRESS* rgContainerProgress;
+    DWORD cContainerProgress;
+    STRINGDICT_HANDLE shContainerProgress;
+
+    BURN_CACHE_PAYLOAD_PROGRESS* rgPayloadProgress;
+    DWORD cPayloadProgress;
+    STRINGDICT_HANDLE shPayloadProgress;
+} BURN_PLAN;
+
+
+// functions
+
+void PlanReset(
+    __in BURN_PLAN* pPlan,
+    __in BURN_PACKAGES* pPackages
+    );
+void PlanUninitializeExecuteAction(
+    __in BURN_EXECUTE_ACTION* pExecuteAction
+    );
+HRESULT PlanSetVariables(
+    __in BOOTSTRAPPER_ACTION action,
+    __in BURN_VARIABLES* pVariables
+    );
+HRESULT PlanDefaultPackageRequestState(
+    __in BURN_PACKAGE_TYPE packageType,
+    __in BOOTSTRAPPER_PACKAGE_STATE currentState,
+    __in BOOL fPermanent,
+    __in BOOTSTRAPPER_ACTION action,
+    __in BURN_VARIABLES* pVariables,
+    __in_z_opt LPCWSTR wzInstallCondition,
+    __in BOOTSTRAPPER_RELATION_TYPE relationType,
+    __out BOOTSTRAPPER_REQUEST_STATE* pRequestState
+    );
+HRESULT PlanLayoutBundle(
+    __in BURN_PLAN* pPlan,
+    __in_z LPCWSTR wzExecutableName,
+    __in DWORD64 qwBundleSize,
+    __in BURN_VARIABLES* pVariables,
+    __in BURN_PAYLOADS* pPayloads,
+    __out_z LPWSTR* psczLayoutDirectory
+    );
+HRESULT PlanPackages(
+    __in BURN_REGISTRATION* pRegistration,
+    __in BURN_USER_EXPERIENCE* pUX,
+    __in BURN_PACKAGES* pPackages,
+    __in BURN_PLAN* pPlan,
+    __in BURN_LOGGING* pLog,
+    __in BURN_VARIABLES* pVariables,
+    __in BOOL fBundleInstalled,
+    __in BOOTSTRAPPER_DISPLAY display,
+    __in BOOTSTRAPPER_RELATION_TYPE relationType,
+    __in_z_opt LPCWSTR wzLayoutDirectory,
+    __inout HANDLE* phSyncpointEvent
+    );
+HRESULT PlanRegistration(
+    __in BURN_PLAN* pPlan,
+    __in BURN_REGISTRATION* pRegistration,
+    __in BOOTSTRAPPER_RESUME_TYPE resumeType,
+    __in BOOTSTRAPPER_RELATION_TYPE relationType,
+    __in_z_opt LPCWSTR wzIgnoreDependencies,
+    __out BOOL* pfContinuePlanning
+    );
+HRESULT PlanPassThroughBundle(
+    __in BURN_USER_EXPERIENCE* pUX,
+    __in BURN_PACKAGE* pPackage,
+    __in BURN_PLAN* pPlan,
+    __in BURN_LOGGING* pLog,
+    __in BURN_VARIABLES* pVariables,
+    __in BOOTSTRAPPER_DISPLAY display,
+    __in BOOTSTRAPPER_RELATION_TYPE relationType,
+    __inout HANDLE* phSyncpointEvent
+    );
+HRESULT PlanUpdateBundle(
+    __in BURN_USER_EXPERIENCE* pUX,
+    __in BURN_PACKAGE* pPackage,
+    __in BURN_PLAN* pPlan,
+    __in BURN_LOGGING* pLog,
+    __in BURN_VARIABLES* pVariables,
+    __in BOOTSTRAPPER_DISPLAY display,
+    __in BOOTSTRAPPER_RELATION_TYPE relationType,
+    __inout HANDLE* phSyncpointEvent
+    );
+HRESULT PlanLayoutPackage(
+    __in BURN_PLAN* pPlan,
+    __in BURN_PACKAGE* pPackage,
+    __in_z_opt LPCWSTR wzLayoutDirectory
+    );
+HRESULT PlanCachePackage(
+    __in BOOL fPerMachine,
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in BURN_PLAN* pPlan,
+    __in BURN_PACKAGE* pPackage,
+    __in BURN_VARIABLES* pVariables,
+    __out HANDLE* phSyncpointEvent
+    );
+HRESULT PlanExecutePackage(
+    __in BOOL fPerMachine,
+    __in BOOTSTRAPPER_DISPLAY display,
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in BURN_PLAN* pPlan,
+    __in BURN_PACKAGE* pPackage,
+    __in BURN_LOGGING* pLog,
+    __in BURN_VARIABLES* pVariables,
+    __inout HANDLE* phSyncpointEvent
+    );
+HRESULT PlanRelatedBundlesBegin(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in BURN_REGISTRATION* pRegistration,
+    __in BOOTSTRAPPER_RELATION_TYPE relationType,
+    __in BURN_PLAN* pPlan
+    );
+HRESULT PlanRelatedBundlesComplete(
+    __in BURN_REGISTRATION* pRegistration,
+    __in BURN_PLAN* pPlan,
+    __in BURN_LOGGING* pLog,
+    __in BURN_VARIABLES* pVariables,
+    __inout HANDLE* phSyncpointEvent,
+    __in DWORD dwExecuteActionEarlyIndex
+    );
+HRESULT PlanFinalizeActions(
+    __in BURN_PLAN* pPlan
+    );
+HRESULT PlanCleanPackage(
+    __in BURN_PLAN* pPlan,
+    __in BURN_PACKAGE* pPackage
+    );
+HRESULT PlanExecuteCacheSyncAndRollback(
+    __in BURN_PLAN* pPlan,
+    __in BURN_PACKAGE* pPackage,
+    __in HANDLE hCacheEvent,
+    __in BOOL fPlanPackageCacheRollback
+    );
+HRESULT PlanExecuteCheckpoint(
+    __in BURN_PLAN* pPlan
+    );
+HRESULT PlanInsertExecuteAction(
+    __in DWORD dwIndex,
+    __in BURN_PLAN* pPlan,
+    __out BURN_EXECUTE_ACTION** ppExecuteAction
+    );
+HRESULT PlanInsertRollbackAction(
+    __in DWORD dwIndex,
+    __in BURN_PLAN* pPlan,
+    __out BURN_EXECUTE_ACTION** ppRollbackAction
+    );
+HRESULT PlanAppendExecuteAction(
+    __in BURN_PLAN* pPlan,
+    __out BURN_EXECUTE_ACTION** ppExecuteAction
+    );
+HRESULT PlanAppendRollbackAction(
+    __in BURN_PLAN* pPlan,
+    __out BURN_EXECUTE_ACTION** ppExecuteAction
+    );
+HRESULT PlanKeepRegistration(
+    __in BURN_PLAN* pPlan,
+    __in DWORD iAfterExecutePackageAction,
+    __in DWORD iBeforeRollbackPackageAction
+    );
+HRESULT PlanRemoveRegistration(
+    __in BURN_PLAN* pPlan,
+    __in DWORD iAfterExecutePackageAction,
+    __in DWORD iAfterRollbackPackageAction
+    );
+HRESULT PlanRollbackBoundaryBegin(
+    __in BURN_PLAN* pPlan,
+    __in BURN_ROLLBACK_BOUNDARY* pRollbackBoundary
+    );
+HRESULT PlanRollbackBoundaryComplete(
+    __in BURN_PLAN* pPlan
+    );
+HRESULT PlanSetResumeCommand(
+    __in BURN_REGISTRATION* pRegistration,
+    __in BOOTSTRAPPER_ACTION action,
+    __in BOOTSTRAPPER_COMMAND* pCommand,
+    __in BURN_LOGGING* pLog
+    );
+
+#ifdef DEBUG
+void PlanDump(
+    __in BURN_PLAN* pPlan
+    );
+#endif
+
+#if defined(__cplusplus)
+}
+#endif
diff --git a/src/engine/platform.cpp b/src/engine/platform.cpp
new file mode 100644
index 00000000..9469ff49
--- /dev/null
+++ b/src/engine/platform.cpp
@@ -0,0 +1,16 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+#include "precomp.h"
+
+
+// variables
+
+PFN_INITIATESYSTEMSHUTDOWNEXW vpfnInitiateSystemShutdownExW;
+
+
+// function definitions
+
+extern "C" void PlatformInitialize()
+{
+    vpfnInitiateSystemShutdownExW = ::InitiateSystemShutdownExW;
+}
diff --git a/src/engine/platform.h b/src/engine/platform.h
new file mode 100644
index 00000000..3681f248
--- /dev/null
+++ b/src/engine/platform.h
@@ -0,0 +1,34 @@
+#pragma once
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+
+// typedefs
+
+typedef BOOL (WINAPI *PFN_INITIATESYSTEMSHUTDOWNEXW)(
+    __in_opt LPWSTR lpMachineName,
+    __in_opt LPWSTR lpMessage,
+    __in DWORD dwTimeout,
+    __in BOOL bForceAppsClosed,
+    __in BOOL bRebootAfterShutdown,
+    __in DWORD dwReason
+    );
+
+
+// variable declarations
+
+extern PFN_INITIATESYSTEMSHUTDOWNEXW vpfnInitiateSystemShutdownExW;
+
+
+// function declarations
+
+void PlatformInitialize();
+
+
+#if defined(__cplusplus)
+}
+#endif
diff --git a/src/engine/precomp.h b/src/engine/precomp.h
new file mode 100644
index 00000000..d3ebe354
--- /dev/null
+++ b/src/engine/precomp.h
@@ -0,0 +1,100 @@
+#pragma once
+// 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.
+
+
+#define ExitTrace LogErrorString
+
+#include <wixver.h>
+
+#include <windows.h>
+#include <aclapi.h>
+#include <Bits.h>
+#include <gdiplus.h>
+#include <math.h>
+#include <msiquery.h>
+#include <sddl.h>
+#include <shlobj.h>
+#include <shlwapi.h>
+#include <softpub.h>
+#include <strsafe.h>
+#include <intsafe.h>
+#include <mscat.h>
+#include <lmcons.h>
+#include <wininet.h>
+#include <stddef.h>
+
+#include <dutil.h>
+#include <aclutil.h>
+#include <apputil.h>
+#include <buffutil.h>
+#include <cabutil.h>
+#include <certutil.h>
+#include <cryputil.h>
+#include <dirutil.h>
+#include <fileutil.h>
+#include <gdiputil.h>
+#include <guidutil.h>
+#include <logutil.h>
+#include <memutil.h>
+#include <osutil.h>
+#include <pathutil.h>
+#include <polcutil.h>
+#include <procutil.h>
+#include <regutil.h>
+#include <resrutil.h>
+#include <shelutil.h>
+#include <srputil.h>
+#include <strutil.h>
+#include <svcutil.h>
+#include <userutil.h>
+#include <wiutil.h>
+#include <wuautil.h>
+#include <xmlutil.h>
+#include <dictutil.h>
+#include <deputil.h>
+#include <dlutil.h>
+#include <atomutil.h>
+#include <apuputil.h>
+
+#include "BootstrapperEngine.h"
+#include "BootstrapperApplication.h"
+
+#include "platform.h"
+#include "variant.h"
+#include "variable.h"
+#include "condition.h"
+#include "search.h"
+#include "section.h"
+#include "approvedexe.h"
+#include "container.h"
+#include "catalog.h"
+#include "payload.h"
+#include "cabextract.h"
+#include "userexperience.h"
+#include "package.h"
+#include "update.h"
+#include "pseudobundle.h"
+#include "registration.h"
+#include "relatedbundle.h"
+#include "detect.h"
+#include "plan.h"
+#include "logging.h"
+#include "pipe.h"
+#include "core.h"
+#include "cache.h"
+#include "apply.h"
+#include "exeengine.h"
+#include "msiengine.h"
+#include "mspengine.h"
+#include "msuengine.h"
+#include "dependency.h"
+#include "elevation.h"
+#include "embedded.h"
+#include "manifest.h"
+#include "splashscreen.h"
+#include "uithread.h"
+#include "bitsengine.h"
+#include "netfxchainer.h"
+
+#include "EngineForApplication.h"
+#include "engine.messages.h"
diff --git a/src/engine/pseudobundle.cpp b/src/engine/pseudobundle.cpp
new file mode 100644
index 00000000..ebdc040a
--- /dev/null
+++ b/src/engine/pseudobundle.cpp
@@ -0,0 +1,271 @@
+// 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.
+
+#include "precomp.h"
+
+
+extern "C" HRESULT PseudoBundleInitialize(
+    __in DWORD64 qwEngineVersion,
+    __in BURN_PACKAGE* pPackage,
+    __in BOOL fPerMachine,
+    __in_z LPCWSTR wzId,
+    __in BOOTSTRAPPER_RELATION_TYPE relationType,
+    __in BOOTSTRAPPER_PACKAGE_STATE state,
+    __in_z LPCWSTR wzFilePath,
+    __in_z LPCWSTR wzLocalSource,
+    __in_z_opt LPCWSTR wzDownloadSource,
+    __in DWORD64 qwSize,
+    __in BOOL fVital,
+    __in_z_opt LPCWSTR wzInstallArguments,
+    __in_z_opt LPCWSTR wzRepairArguments,
+    __in_z_opt LPCWSTR wzUninstallArguments,
+    __in_opt BURN_DEPENDENCY_PROVIDER* pDependencyProvider,
+    __in_opt BYTE* pbHash,
+    __in DWORD cbHash
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR sczRelationTypeCommandLineSwitch = NULL;
+
+    LPCWSTR wzRelationTypeCommandLine = CoreRelationTypeToCommandLineString(relationType);
+    if (wzRelationTypeCommandLine)
+    {
+        hr = StrAllocFormatted(&sczRelationTypeCommandLineSwitch, L" -%ls", wzRelationTypeCommandLine);
+    }
+
+    // Initialize the single payload, and fill out all the necessary fields
+    pPackage->rgPayloads = (BURN_PACKAGE_PAYLOAD *)MemAlloc(sizeof(BURN_PACKAGE_PAYLOAD), TRUE); 
+    ExitOnNull(pPackage->rgPayloads, hr, E_OUTOFMEMORY, "Failed to allocate space for burn package payload inside of related bundle struct");
+    pPackage->cPayloads = 1;
+
+    pPackage->rgPayloads->pPayload = (BURN_PAYLOAD *)MemAlloc(sizeof(BURN_PAYLOAD), TRUE); 
+    ExitOnNull(pPackage->rgPayloads, hr, E_OUTOFMEMORY, "Failed to allocate space for burn payload inside of related bundle struct");
+    pPackage->rgPayloads->pPayload->packaging = BURN_PAYLOAD_PACKAGING_EXTERNAL;
+    pPackage->rgPayloads->pPayload->qwFileSize = qwSize;
+
+    hr = StrAllocString(&pPackage->rgPayloads->pPayload->sczKey, wzId, 0);
+    ExitOnFailure(hr, "Failed to copy key for pseudo bundle payload.");
+
+    hr = StrAllocString(&pPackage->rgPayloads->pPayload->sczFilePath, wzFilePath, 0);
+    ExitOnFailure(hr, "Failed to copy filename for pseudo bundle.");
+
+    hr = StrAllocString(&pPackage->rgPayloads->pPayload->sczSourcePath, wzLocalSource, 0);
+    ExitOnFailure(hr, "Failed to copy local source path for pseudo bundle.");
+
+    if (wzDownloadSource && *wzDownloadSource)
+    {
+        hr = StrAllocString(&pPackage->rgPayloads->pPayload->downloadSource.sczUrl, wzDownloadSource, 0);
+        ExitOnFailure(hr, "Failed to copy download source for pseudo bundle.");
+    }
+
+    if (pbHash)
+    {
+        pPackage->rgPayloads->pPayload->pbHash = static_cast<BYTE*>(MemAlloc(cbHash, FALSE));
+        ExitOnNull(pPackage->rgPayloads->pPayload->pbHash, hr, E_OUTOFMEMORY, "Failed to allocate memory for pseudo bundle payload hash.");
+
+        pPackage->rgPayloads->pPayload->cbHash = cbHash;
+        memcpy_s(pPackage->rgPayloads->pPayload->pbHash, pPackage->rgPayloads->pPayload->cbHash, pbHash, cbHash);
+    }
+
+    pPackage->rgPayloads->fCached = (BOOTSTRAPPER_PACKAGE_STATE_PRESENT == state || BOOTSTRAPPER_PACKAGE_STATE_CACHED == state);
+
+    pPackage->Exe.fPseudoBundle = TRUE;
+
+    pPackage->type = BURN_PACKAGE_TYPE_EXE;
+    pPackage->fPerMachine = fPerMachine;
+    pPackage->currentState = state;
+    pPackage->cache = (BOOTSTRAPPER_PACKAGE_STATE_PRESENT == state || BOOTSTRAPPER_PACKAGE_STATE_CACHED == state) ? BURN_CACHE_STATE_COMPLETE : BURN_CACHE_STATE_NONE;
+    pPackage->qwInstallSize = qwSize;
+    pPackage->qwSize = qwSize;
+    pPackage->fVital = fVital;
+
+    hr = StrAllocString(&pPackage->sczId, wzId, 0);
+    ExitOnFailure(hr, "Failed to copy key for pseudo bundle.");
+
+    hr = StrAllocString(&pPackage->sczCacheId, wzId, 0);
+    ExitOnFailure(hr, "Failed to copy cache id for pseudo bundle.");
+
+    // If we are a self updating bundle, we don't have to have Install arguments.
+    if (wzInstallArguments)
+    {
+        hr = StrAllocString(&pPackage->Exe.sczInstallArguments, wzInstallArguments, 0);
+        ExitOnFailure(hr, "Failed to copy install arguments for related bundle package");
+    }
+
+    if (sczRelationTypeCommandLineSwitch)
+    {
+        hr = StrAllocConcat(&pPackage->Exe.sczInstallArguments, sczRelationTypeCommandLineSwitch, 0);
+        ExitOnFailure(hr, "Failed to append relation type to install arguments for related bundle package");
+    }
+
+    if (wzRepairArguments)
+    {
+        hr = StrAllocString(&pPackage->Exe.sczRepairArguments, wzRepairArguments, 0);
+        ExitOnFailure(hr, "Failed to copy repair arguments for related bundle package");
+
+        if (sczRelationTypeCommandLineSwitch)
+        {
+            hr = StrAllocConcat(&pPackage->Exe.sczRepairArguments, sczRelationTypeCommandLineSwitch, 0);
+            ExitOnFailure(hr, "Failed to append relation type to repair arguments for related bundle package");
+        }
+
+        pPackage->Exe.fRepairable = TRUE;
+    }
+
+    if (wzUninstallArguments)
+    {
+        hr = StrAllocString(&pPackage->Exe.sczUninstallArguments, wzUninstallArguments, 0);
+        ExitOnFailure(hr, "Failed to copy uninstall arguments for related bundle package");
+
+        if (sczRelationTypeCommandLineSwitch)
+        {
+            hr = StrAllocConcat(&pPackage->Exe.sczUninstallArguments, sczRelationTypeCommandLineSwitch, 0);
+            ExitOnFailure(hr, "Failed to append relation type to uninstall arguments for related bundle package");
+        }
+
+        pPackage->fUninstallable = TRUE;
+    }
+
+    // Only support progress from engines that are compatible (aka: version greater than or equal to last protocol breaking change *and* versions that are older or the same as this engine).
+    pPackage->Exe.protocol = (FILEMAKEVERSION(3, 6, 2221, 0) <= qwEngineVersion && qwEngineVersion <= FILEMAKEVERSION(rmj, rmm, rup, 0)) ? BURN_EXE_PROTOCOL_TYPE_BURN : BURN_EXE_PROTOCOL_TYPE_NONE;
+    
+    // All versions of Burn past v3.9 RTM support suppressing ancestors.
+    pPackage->Exe.fSupportsAncestors = FILEMAKEVERSION(3, 9, 1006, 0) <= qwEngineVersion;
+
+    if (pDependencyProvider)
+    {
+        pPackage->rgDependencyProviders = (BURN_DEPENDENCY_PROVIDER*)MemAlloc(sizeof(BURN_DEPENDENCY_PROVIDER), TRUE);
+        ExitOnNull(pPackage->rgDependencyProviders, hr, E_OUTOFMEMORY, "Failed to allocate memory for dependency providers.");
+        pPackage->cDependencyProviders = 1;
+
+        pPackage->rgDependencyProviders[0].fImported = pDependencyProvider->fImported;
+
+        hr = StrAllocString(&pPackage->rgDependencyProviders[0].sczKey, pDependencyProvider->sczKey, 0);
+        ExitOnFailure(hr, "Failed to copy key for pseudo bundle.");
+
+        hr = StrAllocString(&pPackage->rgDependencyProviders[0].sczVersion, pDependencyProvider->sczVersion, 0);
+        ExitOnFailure(hr, "Failed to copy version for pseudo bundle.");
+
+        hr = StrAllocString(&pPackage->rgDependencyProviders[0].sczDisplayName, pDependencyProvider->sczDisplayName, 0);
+        ExitOnFailure(hr, "Failed to copy display name for pseudo bundle.");
+    }
+
+LExit:
+    ReleaseStr(sczRelationTypeCommandLineSwitch);
+
+    return hr;
+}
+
+extern "C" HRESULT PseudoBundleInitializePassthrough(
+    __in BURN_PACKAGE* pPassthroughPackage,
+    __in BOOTSTRAPPER_COMMAND* pCommand,
+    __in_z_opt LPCWSTR wzAppendLogPath,
+    __in_z_opt LPWSTR wzActiveParent,
+    __in_z_opt LPWSTR wzAncestors,
+    __in BURN_PACKAGE* pPackage
+    )
+{
+    Assert(BURN_PACKAGE_TYPE_EXE == pPackage->type);
+
+    HRESULT hr = S_OK;
+    LPWSTR sczArguments = NULL;
+
+    // Initialize the payloads, and copy the necessary fields.
+    pPassthroughPackage->rgPayloads = (BURN_PACKAGE_PAYLOAD *)MemAlloc(sizeof(BURN_PACKAGE_PAYLOAD) * pPackage->cPayloads, TRUE);
+    ExitOnNull(pPassthroughPackage->rgPayloads, hr, E_OUTOFMEMORY, "Failed to allocate space for burn package payload inside of passthrough bundle.");
+    pPassthroughPackage->cPayloads = pPackage->cPayloads;
+
+    for (DWORD iPayload = 0; iPayload < pPackage->cPayloads; ++iPayload)
+    {
+        BURN_PACKAGE_PAYLOAD* pPayload = pPackage->rgPayloads + iPayload;
+
+        pPassthroughPackage->rgPayloads[iPayload].pPayload = (BURN_PAYLOAD *)MemAlloc(sizeof(BURN_PAYLOAD), TRUE); 
+        ExitOnNull(pPassthroughPackage->rgPayloads[iPayload].pPayload, hr, E_OUTOFMEMORY, "Failed to allocate space for burn payload inside of related bundle struct");
+        pPassthroughPackage->rgPayloads[iPayload].pPayload->packaging = pPayload->pPayload->packaging;
+        pPassthroughPackage->rgPayloads[iPayload].pPayload->qwFileSize = pPayload->pPayload->qwFileSize;
+
+        hr = StrAllocString(&pPassthroughPackage->rgPayloads[iPayload].pPayload->sczKey, pPayload->pPayload->sczKey, 0);
+        ExitOnFailure(hr, "Failed to copy key for passthrough pseudo bundle payload.");
+
+        hr = StrAllocString(&pPassthroughPackage->rgPayloads[iPayload].pPayload->sczFilePath, pPayload->pPayload->sczFilePath, 0);
+        ExitOnFailure(hr, "Failed to copy filename for passthrough pseudo bundle.");
+
+        hr = StrAllocString(&pPassthroughPackage->rgPayloads[iPayload].pPayload->sczSourcePath, pPayload->pPayload->sczSourcePath, 0);
+        ExitOnFailure(hr, "Failed to copy local source path for passthrough pseudo bundle.");
+
+        if (pPayload->pPayload->downloadSource.sczUrl)
+        {
+            hr = StrAllocString(&pPassthroughPackage->rgPayloads[iPayload].pPayload->downloadSource.sczUrl, pPayload->pPayload->downloadSource.sczUrl, 0);
+            ExitOnFailure(hr, "Failed to copy download source for passthrough pseudo bundle.");
+        }
+
+        if (pPayload->pPayload->pbHash)
+        {
+            pPassthroughPackage->rgPayloads[iPayload].pPayload->pbHash = static_cast<BYTE*>(MemAlloc(pPayload->pPayload->cbHash, FALSE));
+            ExitOnNull(pPassthroughPackage->rgPayloads[iPayload].pPayload->pbHash, hr, E_OUTOFMEMORY, "Failed to allocate memory for pseudo bundle payload hash.");
+
+            pPassthroughPackage->rgPayloads[iPayload].pPayload->cbHash = pPayload->pPayload->cbHash;
+            memcpy_s(pPassthroughPackage->rgPayloads[iPayload].pPayload->pbHash, pPassthroughPackage->rgPayloads[iPayload].pPayload->cbHash, pPayload->pPayload->pbHash, pPayload->pPayload->cbHash);
+        }
+
+        pPassthroughPackage->rgPayloads[iPayload].fCached = pPayload->fCached;
+    }
+
+    pPassthroughPackage->Exe.fPseudoBundle = TRUE;
+
+    pPassthroughPackage->fPerMachine = FALSE; // passthrough bundles are always launched per-user.
+    pPassthroughPackage->type = pPackage->type;
+    pPassthroughPackage->currentState = pPackage->currentState;
+    pPassthroughPackage->cache = pPackage->cache;
+    pPassthroughPackage->qwInstallSize = pPackage->qwInstallSize;
+    pPassthroughPackage->qwSize = pPackage->qwSize;
+    pPassthroughPackage->fVital = pPackage->fVital;
+
+    hr = StrAllocString(&pPassthroughPackage->sczId, pPackage->sczId, 0);
+    ExitOnFailure(hr, "Failed to copy key for passthrough pseudo bundle.");
+
+    hr = StrAllocString(&pPassthroughPackage->sczCacheId, pPackage->sczCacheId, 0);
+    ExitOnFailure(hr, "Failed to copy cache id for passthrough pseudo bundle.");
+
+    pPassthroughPackage->Exe.protocol = pPackage->Exe.protocol;
+
+    // No matter the operation, we're passing the same command-line. That's what makes
+    // this a passthrough bundle.
+    hr = CoreRecreateCommandLine(&sczArguments, pCommand->action, pCommand->display, pCommand->restart, pCommand->relationType, TRUE, wzActiveParent, wzAncestors, wzAppendLogPath, pCommand->wzCommandLine);
+    ExitOnFailure(hr, "Failed to recreate command-line arguments.");
+
+    hr = StrAllocString(&pPassthroughPackage->Exe.sczInstallArguments, sczArguments, 0);
+    ExitOnFailure(hr, "Failed to copy install arguments for passthrough bundle package");
+
+    hr = StrAllocString(&pPassthroughPackage->Exe.sczRepairArguments, sczArguments, 0);
+    ExitOnFailure(hr, "Failed to copy related arguments for passthrough bundle package");
+
+    pPassthroughPackage->Exe.fRepairable = TRUE;
+
+    hr = StrAllocString(&pPassthroughPackage->Exe.sczUninstallArguments, sczArguments, 0);
+    ExitOnFailure(hr, "Failed to copy uninstall arguments for passthrough bundle package");
+
+    pPassthroughPackage->fUninstallable = TRUE;
+
+    // TODO: consider bringing this back in the near future.
+    //if (pDependencyProvider)
+    //{
+    //    pPassthroughPackage->rgDependencyProviders = (BURN_DEPENDENCY_PROVIDER*)MemAlloc(sizeof(BURN_DEPENDENCY_PROVIDER), TRUE);
+    //    ExitOnNull(pPassthroughPackage->rgDependencyProviders, hr, E_OUTOFMEMORY, "Failed to allocate memory for dependency providers.");
+    //    pPassthroughPackage->cDependencyProviders = 1;
+
+    //    pPassthroughPackage->rgDependencyProviders[0].fImported = pDependencyProvider->fImported;
+
+    //    hr = StrAllocString(&pPassthroughPackage->rgDependencyProviders[0].sczKey, pDependencyProvider->sczKey, 0);
+    //    ExitOnFailure(hr, "Failed to copy key for pseudo bundle.");
+
+    //    hr = StrAllocString(&pPassthroughPackage->rgDependencyProviders[0].sczVersion, pDependencyProvider->sczVersion, 0);
+    //    ExitOnFailure(hr, "Failed to copy version for pseudo bundle.");
+
+    //    hr = StrAllocString(&pPassthroughPackage->rgDependencyProviders[0].sczDisplayName, pDependencyProvider->sczDisplayName, 0);
+    //    ExitOnFailure(hr, "Failed to copy display name for pseudo bundle.");
+    //}
+
+LExit:
+    ReleaseStr(sczArguments);
+    return hr;
+}
diff --git a/src/engine/pseudobundle.h b/src/engine/pseudobundle.h
new file mode 100644
index 00000000..144f6880
--- /dev/null
+++ b/src/engine/pseudobundle.h
@@ -0,0 +1,39 @@
+#pragma once
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+HRESULT PseudoBundleInitialize(
+    __in DWORD64 qwEngineVersion,
+    __in BURN_PACKAGE* pPackage,
+    __in BOOL fPerMachine,
+    __in_z LPCWSTR wzId,
+    __in BOOTSTRAPPER_RELATION_TYPE relationType,
+    __in BOOTSTRAPPER_PACKAGE_STATE state,
+    __in_z LPCWSTR wzFilePath,
+    __in_z LPCWSTR wzLocalSource,
+    __in_z_opt LPCWSTR wzDownloadSource,
+    __in DWORD64 qwSize,
+    __in BOOL fVital,
+    __in_z_opt LPCWSTR wzInstallArguments,
+    __in_z_opt LPCWSTR wzRepairArguments,
+    __in_z_opt LPCWSTR wzUninstallArguments,
+    __in_opt BURN_DEPENDENCY_PROVIDER* pDependencyProvider,
+    __in_opt BYTE* pbHash,
+    __in DWORD cbHash
+    );
+HRESULT PseudoBundleInitializePassthrough(
+    __in BURN_PACKAGE* pPassthroughPackage,
+    __in BOOTSTRAPPER_COMMAND* pCommand,
+    __in_z_opt LPCWSTR wzAppendLogPath,
+    __in_z_opt LPWSTR wzActiveParent,
+    __in_z_opt LPWSTR wzAncestors,
+    __in BURN_PACKAGE* pPackage
+    );
+
+#if defined(__cplusplus)
+}
+#endif
diff --git a/src/engine/registration.cpp b/src/engine/registration.cpp
new file mode 100644
index 00000000..93c990f5
--- /dev/null
+++ b/src/engine/registration.cpp
@@ -0,0 +1,1599 @@
+// 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.
+
+#include "precomp.h"
+
+
+// constants
+
+const LPCWSTR REGISTRY_RUN_KEY = L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run";
+const LPCWSTR REGISTRY_RUN_ONCE_KEY = L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\RunOnce";
+const LPCWSTR REGISTRY_REBOOT_PENDING_FORMAT = L"%ls.RebootRequired";
+const LPCWSTR REGISTRY_BUNDLE_INSTALLED = L"Installed";
+const LPCWSTR REGISTRY_BUNDLE_DISPLAY_ICON = L"DisplayIcon";
+const LPCWSTR REGISTRY_BUNDLE_DISPLAY_VERSION = L"DisplayVersion";
+const LPCWSTR REGISTRY_BUNDLE_ESTIMATED_SIZE = L"EstimatedSize";
+const LPCWSTR REGISTRY_BUNDLE_PUBLISHER = L"Publisher";
+const LPCWSTR REGISTRY_BUNDLE_HELP_LINK = L"HelpLink";
+const LPCWSTR REGISTRY_BUNDLE_HELP_TELEPHONE = L"HelpTelephone";
+const LPCWSTR REGISTRY_BUNDLE_URL_INFO_ABOUT = L"URLInfoAbout";
+const LPCWSTR REGISTRY_BUNDLE_URL_UPDATE_INFO = L"URLUpdateInfo";
+const LPCWSTR REGISTRY_BUNDLE_PARENT_DISPLAY_NAME = L"ParentDisplayName";
+const LPCWSTR REGISTRY_BUNDLE_PARENT_KEY_NAME = L"ParentKeyName";
+const LPCWSTR REGISTRY_BUNDLE_COMMENTS = L"Comments";
+const LPCWSTR REGISTRY_BUNDLE_CONTACT = L"Contact";
+const LPCWSTR REGISTRY_BUNDLE_NO_MODIFY = L"NoModify";
+const LPCWSTR REGISTRY_BUNDLE_MODIFY_PATH = L"ModifyPath";
+const LPCWSTR REGISTRY_BUNDLE_NO_ELEVATE_ON_MODIFY = L"NoElevateOnModify";
+const LPCWSTR REGISTRY_BUNDLE_NO_REMOVE = L"NoRemove";
+const LPCWSTR REGISTRY_BUNDLE_SYSTEM_COMPONENT = L"SystemComponent";
+const LPCWSTR REGISTRY_BUNDLE_QUIET_UNINSTALL_STRING = L"QuietUninstallString";
+const LPCWSTR REGISTRY_BUNDLE_UNINSTALL_STRING = L"UninstallString";
+const LPCWSTR REGISTRY_BUNDLE_RESUME_COMMAND_LINE = L"BundleResumeCommandLine";
+const LPCWSTR REGISTRY_BUNDLE_VERSION_MAJOR = L"VersionMajor";
+const LPCWSTR REGISTRY_BUNDLE_VERSION_MINOR = L"VersionMinor";
+
+// internal function declarations
+
+static HRESULT ParseSoftwareTagsFromXml(
+    __in IXMLDOMNode* pixnRegistrationNode,
+    __out BURN_SOFTWARE_TAG** prgSoftwareTags,
+    __out DWORD* pcSoftwareTags
+    );
+static HRESULT SetPaths(
+    __in BURN_REGISTRATION* pRegistration
+    );
+static HRESULT GetBundleManufacturer(
+    __in BURN_REGISTRATION* pRegistration,
+    __in BURN_VARIABLES* pVariables,
+    __out LPWSTR* psczBundleManufacturer
+    );
+static HRESULT GetBundleName(
+    __in BURN_REGISTRATION* pRegistration,
+    __in BURN_VARIABLES* pVariables,
+    __out LPWSTR* psczBundleName
+    );
+static HRESULT UpdateResumeMode(
+    __in BURN_REGISTRATION* pRegistration,
+    __in HKEY hkRegistration,
+    __in BURN_RESUME_MODE resumeMode,
+    __in BOOL fRestartInitiated
+    );
+static HRESULT ParseRelatedCodes(
+    __in BURN_REGISTRATION* pRegistration,
+    __in IXMLDOMNode* pixnBundle
+    );
+static HRESULT FormatUpdateRegistrationKey(
+    __in BURN_REGISTRATION* pRegistration,
+    __out_z LPWSTR* psczKey
+    );
+static HRESULT WriteSoftwareTags(
+    __in BOOL fPerMachine,
+    __in BURN_SOFTWARE_TAGS* pSoftwareTags
+    );
+static HRESULT RemoveSoftwareTags(
+    __in BOOL fPerMachine,
+    __in BURN_SOFTWARE_TAGS* pSoftwareTags
+    );
+static HRESULT WriteUpdateRegistration(
+    __in BURN_REGISTRATION* pRegistration,
+    __in BURN_VARIABLES* pVariables
+    );
+static HRESULT RemoveUpdateRegistration(
+    __in BURN_REGISTRATION* pRegistration
+    );
+static HRESULT RegWriteStringVariable(
+    __in HKEY hkKey,
+    __in BURN_VARIABLES* pVariables,
+    __in LPCWSTR wzVariable,
+    __in LPCWSTR wzName
+    );
+static HRESULT UpdateBundleNameRegistration(
+    __in BURN_REGISTRATION* pRegistration,
+    __in BURN_VARIABLES* pVariables,
+    __in HKEY hkRegistration
+    );
+
+// function definitions
+
+/*******************************************************************
+ RegistrationParseFromXml - Parses registration information from manifest.
+
+*******************************************************************/
+extern "C" HRESULT RegistrationParseFromXml(
+    __in BURN_REGISTRATION* pRegistration,
+    __in IXMLDOMNode* pixnBundle
+    )
+{
+    HRESULT hr = S_OK;
+    IXMLDOMNode* pixnRegistrationNode = NULL;
+    IXMLDOMNode* pixnArpNode = NULL;
+    IXMLDOMNode* pixnUpdateNode = NULL;
+    LPWSTR scz = NULL;
+
+    // select registration node
+    hr = XmlSelectSingleNode(pixnBundle, L"Registration", &pixnRegistrationNode);
+    if (S_FALSE == hr)
+    {
+        hr = E_NOTFOUND;
+    }
+    ExitOnFailure(hr, "Failed to select registration node.");
+
+    // @Id
+    hr = XmlGetAttributeEx(pixnRegistrationNode, L"Id", &pRegistration->sczId);
+    ExitOnFailure(hr, "Failed to get @Id.");
+
+    // @Tag
+    hr = XmlGetAttributeEx(pixnRegistrationNode, L"Tag", &pRegistration->sczTag);
+    ExitOnFailure(hr, "Failed to get @Tag.");
+
+    hr = ParseRelatedCodes(pRegistration, pixnBundle);
+    ExitOnFailure(hr, "Failed to parse related bundles");
+
+    // @Version
+    hr = XmlGetAttributeEx(pixnRegistrationNode, L"Version", &scz);
+    ExitOnFailure(hr, "Failed to get @Version.");
+
+    hr = FileVersionFromStringEx(scz, 0, &pRegistration->qwVersion);
+    ExitOnFailure(hr, "Failed to parse @Version: %ls", scz);
+
+    // @ProviderKey
+    hr = XmlGetAttributeEx(pixnRegistrationNode, L"ProviderKey", &pRegistration->sczProviderKey);
+    ExitOnFailure(hr, "Failed to get @ProviderKey.");
+
+    // @ExecutableName
+    hr = XmlGetAttributeEx(pixnRegistrationNode, L"ExecutableName", &pRegistration->sczExecutableName);
+    ExitOnFailure(hr, "Failed to get @ExecutableName.");
+
+    // @PerMachine
+    hr = XmlGetYesNoAttribute(pixnRegistrationNode, L"PerMachine", &pRegistration->fPerMachine);
+    ExitOnFailure(hr, "Failed to get @PerMachine.");
+
+    // select ARP node
+    hr = XmlSelectSingleNode(pixnRegistrationNode, L"Arp", &pixnArpNode);
+    if (S_FALSE != hr)
+    {
+        ExitOnFailure(hr, "Failed to select ARP node.");
+
+        // @Register
+        hr = XmlGetYesNoAttribute(pixnArpNode, L"Register", &pRegistration->fRegisterArp);
+        ExitOnFailure(hr, "Failed to get @Register.");
+
+        // @DisplayName
+        hr = XmlGetAttributeEx(pixnArpNode, L"DisplayName", &pRegistration->sczDisplayName);
+        if (E_NOTFOUND != hr)
+        {
+            ExitOnFailure(hr, "Failed to get @DisplayName.");
+        }
+
+        // @DisplayVersion
+        hr = XmlGetAttributeEx(pixnArpNode, L"DisplayVersion", &pRegistration->sczDisplayVersion);
+        if (E_NOTFOUND != hr)
+        {
+            ExitOnFailure(hr, "Failed to get @DisplayVersion.");
+        }
+
+        // @Publisher
+        hr = XmlGetAttributeEx(pixnArpNode, L"Publisher", &pRegistration->sczPublisher);
+        if (E_NOTFOUND != hr)
+        {
+            ExitOnFailure(hr, "Failed to get @Publisher.");
+        }
+
+        // @HelpLink
+        hr = XmlGetAttributeEx(pixnArpNode, L"HelpLink", &pRegistration->sczHelpLink);
+        if (E_NOTFOUND != hr)
+        {
+            ExitOnFailure(hr, "Failed to get @HelpLink.");
+        }
+
+        // @HelpTelephone
+        hr = XmlGetAttributeEx(pixnArpNode, L"HelpTelephone", &pRegistration->sczHelpTelephone);
+        if (E_NOTFOUND != hr)
+        {
+            ExitOnFailure(hr, "Failed to get @HelpTelephone.");
+        }
+
+        // @AboutUrl
+        hr = XmlGetAttributeEx(pixnArpNode, L"AboutUrl", &pRegistration->sczAboutUrl);
+        if (E_NOTFOUND != hr)
+        {
+            ExitOnFailure(hr, "Failed to get @AboutUrl.");
+        }
+
+        // @UpdateUrl
+        hr = XmlGetAttributeEx(pixnArpNode, L"UpdateUrl", &pRegistration->sczUpdateUrl);
+        if (E_NOTFOUND != hr)
+        {
+            ExitOnFailure(hr, "Failed to get @UpdateUrl.");
+        }
+
+        // @ParentDisplayName
+        hr = XmlGetAttributeEx(pixnArpNode, L"ParentDisplayName", &pRegistration->sczParentDisplayName);
+        if (E_NOTFOUND != hr)
+        {
+            ExitOnFailure(hr, "Failed to get @ParentDisplayName.");
+        }
+
+        // @Comments
+        hr = XmlGetAttributeEx(pixnArpNode, L"Comments", &pRegistration->sczComments);
+        if (E_NOTFOUND != hr)
+        {
+            ExitOnFailure(hr, "Failed to get @Comments.");
+        }
+
+        // @Contact
+        hr = XmlGetAttributeEx(pixnArpNode, L"Contact", &pRegistration->sczContact);
+        if (E_NOTFOUND != hr)
+        {
+            ExitOnFailure(hr, "Failed to get @Contact.");
+        }
+
+        // @DisableModify
+        hr = XmlGetAttributeEx(pixnArpNode, L"DisableModify", &scz);
+        if (SUCCEEDED(hr))
+        {
+            if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, scz, -1, L"button", -1))
+            {
+                pRegistration->modify = BURN_REGISTRATION_MODIFY_DISABLE_BUTTON;
+            }
+            else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, scz, -1, L"yes", -1))
+            {
+                pRegistration->modify = BURN_REGISTRATION_MODIFY_DISABLE;
+            }
+            else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, scz, -1, L"no", -1))
+            {
+                pRegistration->modify = BURN_REGISTRATION_MODIFY_ENABLED;
+            }
+            else
+            {
+                hr = E_UNEXPECTED;
+                ExitOnRootFailure(hr, "Invalid modify disabled type: %ls", scz);
+            }
+        }
+        else if (E_NOTFOUND == hr)
+        {
+            pRegistration->modify = BURN_REGISTRATION_MODIFY_ENABLED;
+            hr = S_OK;
+        }
+        ExitOnFailure(hr, "Failed to get @DisableModify.");
+
+        // @DisableRemove
+        hr = XmlGetYesNoAttribute(pixnArpNode, L"DisableRemove", &pRegistration->fNoRemove);
+        if (E_NOTFOUND != hr)
+        {
+            ExitOnFailure(hr, "Failed to get @DisableRemove.");
+            pRegistration->fNoRemoveDefined = TRUE;
+        }
+    }
+
+    hr = ParseSoftwareTagsFromXml(pixnRegistrationNode, &pRegistration->softwareTags.rgSoftwareTags, &pRegistration->softwareTags.cSoftwareTags);
+    ExitOnFailure(hr, "Failed to parse software tag.");
+
+    // select Update node
+    hr = XmlSelectSingleNode(pixnRegistrationNode, L"Update", &pixnUpdateNode);
+    if (S_FALSE != hr)
+    {
+        ExitOnFailure(hr, "Failed to select Update node.");
+
+        pRegistration->update.fRegisterUpdate = TRUE;
+
+        // @Manufacturer
+        hr = XmlGetAttributeEx(pixnUpdateNode, L"Manufacturer", &pRegistration->update.sczManufacturer);
+        ExitOnFailure(hr, "Failed to get @Manufacturer.");
+
+        // @Department
+        hr = XmlGetAttributeEx(pixnUpdateNode, L"Department", &pRegistration->update.sczDepartment);
+        if (E_NOTFOUND != hr)
+        {
+            ExitOnFailure(hr, "Failed to get @Department.");
+        }
+
+        // @ProductFamily
+        hr = XmlGetAttributeEx(pixnUpdateNode, L"ProductFamily", &pRegistration->update.sczProductFamily);
+        if (E_NOTFOUND != hr)
+        {
+            ExitOnFailure(hr, "Failed to get @ProductFamily.");
+        }
+
+        // @Name
+        hr = XmlGetAttributeEx(pixnUpdateNode, L"Name", &pRegistration->update.sczName);
+        ExitOnFailure(hr, "Failed to get @Name.");
+
+        // @Classification
+        hr = XmlGetAttributeEx(pixnUpdateNode, L"Classification", &pRegistration->update.sczClassification);
+        ExitOnFailure(hr, "Failed to get @Classification.");
+    }
+
+    hr = SetPaths(pRegistration);
+    ExitOnFailure(hr, "Failed to set registration paths.");
+
+LExit:
+    ReleaseObject(pixnRegistrationNode);
+    ReleaseObject(pixnArpNode);
+    ReleaseObject(pixnUpdateNode);
+    ReleaseStr(scz);
+
+    return hr;
+}
+
+/*******************************************************************
+ RegistrationUninitialize - 
+
+*******************************************************************/
+extern "C" void RegistrationUninitialize(
+    __in BURN_REGISTRATION* pRegistration
+    )
+{
+    ReleaseStr(pRegistration->sczId);
+    ReleaseStr(pRegistration->sczTag);
+
+    for (DWORD i = 0; i < pRegistration->cDetectCodes; ++i)
+    {
+        ReleaseStr(pRegistration->rgsczDetectCodes[i]);
+    }
+    ReleaseMem(pRegistration->rgsczDetectCodes);
+
+    for (DWORD i = 0; i < pRegistration->cUpgradeCodes; ++i)
+    {
+        ReleaseStr(pRegistration->rgsczUpgradeCodes[i]);
+    }
+    ReleaseMem(pRegistration->rgsczUpgradeCodes);
+
+    for (DWORD i = 0; i < pRegistration->cAddonCodes; ++i)
+    {
+        ReleaseStr(pRegistration->rgsczAddonCodes[i]);
+    }
+    ReleaseMem(pRegistration->rgsczAddonCodes);
+
+    for (DWORD i = 0; i < pRegistration->cPatchCodes; ++i)
+    {
+        ReleaseStr(pRegistration->rgsczPatchCodes[i]);
+    }
+    ReleaseMem(pRegistration->rgsczPatchCodes);
+
+    ReleaseStr(pRegistration->sczProviderKey);
+    ReleaseStr(pRegistration->sczActiveParent);
+    ReleaseStr(pRegistration->sczExecutableName);
+
+    ReleaseStr(pRegistration->sczRegistrationKey);
+    ReleaseStr(pRegistration->sczCacheExecutablePath);
+    ReleaseStr(pRegistration->sczResumeCommandLine);
+    ReleaseStr(pRegistration->sczStateFile);
+
+    ReleaseStr(pRegistration->sczDisplayName);
+    ReleaseStr(pRegistration->sczDisplayVersion);
+    ReleaseStr(pRegistration->sczPublisher);
+    ReleaseStr(pRegistration->sczHelpLink);
+    ReleaseStr(pRegistration->sczHelpTelephone);
+    ReleaseStr(pRegistration->sczAboutUrl);
+    ReleaseStr(pRegistration->sczUpdateUrl);
+    ReleaseStr(pRegistration->sczParentDisplayName);
+    ReleaseStr(pRegistration->sczComments);
+    ReleaseStr(pRegistration->sczContact);
+
+    ReleaseStr(pRegistration->update.sczManufacturer);
+    ReleaseStr(pRegistration->update.sczDepartment);
+    ReleaseStr(pRegistration->update.sczProductFamily);
+    ReleaseStr(pRegistration->update.sczName);
+    ReleaseStr(pRegistration->update.sczClassification);
+
+    if (pRegistration->softwareTags.rgSoftwareTags)
+    {
+        for (DWORD i = 0; i < pRegistration->softwareTags.cSoftwareTags; ++i)
+        {
+            ReleaseStr(pRegistration->softwareTags.rgSoftwareTags[i].sczFilename);
+            ReleaseStr(pRegistration->softwareTags.rgSoftwareTags[i].sczRegid);
+            ReleaseStr(pRegistration->softwareTags.rgSoftwareTags[i].sczTag);
+        }
+
+        MemFree(pRegistration->softwareTags.rgSoftwareTags);
+    }
+
+    ReleaseStr(pRegistration->sczDetectedProviderKeyBundleId);
+    ReleaseStr(pRegistration->sczAncestors);
+    RelatedBundlesUninitialize(&pRegistration->relatedBundles);
+
+    // clear struct
+    memset(pRegistration, 0, sizeof(BURN_REGISTRATION));
+}
+
+/*******************************************************************
+ RegistrationSetVariables - Initializes bundle variables that map to
+                            registration entities.
+
+*******************************************************************/
+extern "C" HRESULT RegistrationSetVariables(
+    __in BURN_REGISTRATION* pRegistration,
+    __in BURN_VARIABLES* pVariables
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR sczBundleManufacturer = NULL;
+    LPWSTR sczBundleName = NULL;
+
+    if (pRegistration->fInstalled)
+    {
+        hr = VariableSetNumeric(pVariables, BURN_BUNDLE_INSTALLED, 1, TRUE);
+        ExitOnFailure(hr, "Failed to set the bundle installed built-in variable.");
+    }
+
+    // Ensure the registration bundle name is updated.
+    hr = GetBundleName(pRegistration, pVariables, &sczBundleName);
+    ExitOnFailure(hr, "Failed to initialize bundle name.");
+
+    hr = GetBundleManufacturer(pRegistration, pVariables, &sczBundleName);
+    ExitOnFailure(hr, "Failed to initialize bundle manufacturer.");
+
+    if (pRegistration->sczActiveParent && *pRegistration->sczActiveParent)
+    {
+        hr = VariableSetString(pVariables, BURN_BUNDLE_ACTIVE_PARENT, pRegistration->sczActiveParent, TRUE);
+        ExitOnFailure(hr, "Failed to overwrite the bundle active parent built-in variable.");
+    }
+
+    hr = VariableSetString(pVariables, BURN_BUNDLE_PROVIDER_KEY, pRegistration->sczProviderKey, TRUE);
+    ExitOnFailure(hr, "Failed to overwrite the bundle provider key built-in variable.");
+
+    hr = VariableSetString(pVariables, BURN_BUNDLE_TAG, pRegistration->sczTag, TRUE);
+    ExitOnFailure(hr, "Failed to overwrite the bundle tag built-in variable.");
+
+    hr = VariableSetVersion(pVariables, BURN_BUNDLE_VERSION, pRegistration->qwVersion, TRUE);
+    ExitOnFailure(hr, "Failed to overwrite the bundle tag built-in variable.");
+
+LExit:
+    ReleaseStr(sczBundleManufacturer);
+    ReleaseStr(sczBundleName);
+
+    return hr;
+}
+
+extern "C" HRESULT RegistrationDetectInstalled(
+    __in BURN_REGISTRATION* pRegistration,
+    __out BOOL* pfInstalled
+    )
+{
+    HRESULT hr = S_OK;
+    HKEY hkRegistration = NULL;
+    DWORD dwInstalled = 0;
+
+    // open registration key
+    hr = RegOpen(pRegistration->hkRoot, pRegistration->sczRegistrationKey, KEY_QUERY_VALUE, &hkRegistration);
+    if (SUCCEEDED(hr))
+    {
+        hr = RegReadNumber(hkRegistration, REGISTRY_BUNDLE_INSTALLED, &dwInstalled);
+    }
+
+    // Not finding the key or value is okay.
+    if (E_FILENOTFOUND == hr || E_PATHNOTFOUND == hr)
+    {
+        hr = S_OK;
+    }
+
+    *pfInstalled = (1 == dwInstalled);
+
+    ReleaseRegKey(hkRegistration);
+    return hr;
+}
+
+/*******************************************************************
+ RegistrationDetectResumeMode - Detects registration information on the system
+                                to determine if a resume is taking place.
+
+*******************************************************************/
+extern "C" HRESULT RegistrationDetectResumeType(
+    __in BURN_REGISTRATION* pRegistration,
+    __out BOOTSTRAPPER_RESUME_TYPE* pResumeType
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR sczRebootRequiredKey = NULL;
+    HKEY hkRebootRequired = NULL;
+    HKEY hkRegistration = NULL;
+    DWORD dwResume = 0;
+
+    // Check to see if a restart is pending for this bundle.
+    hr = StrAllocFormatted(&sczRebootRequiredKey, REGISTRY_REBOOT_PENDING_FORMAT, pRegistration->sczRegistrationKey);
+    ExitOnFailure(hr, "Failed to format pending restart registry key to read.");
+
+    hr = RegOpen(pRegistration->hkRoot, sczRebootRequiredKey, KEY_QUERY_VALUE, &hkRebootRequired);
+    if (SUCCEEDED(hr))
+    {
+        *pResumeType = BOOTSTRAPPER_RESUME_TYPE_REBOOT_PENDING;
+        ExitFunction1(hr = S_OK);
+    }
+
+    // open registration key
+    hr = RegOpen(pRegistration->hkRoot, pRegistration->sczRegistrationKey, KEY_QUERY_VALUE, &hkRegistration);
+    if (E_FILENOTFOUND == hr || E_PATHNOTFOUND == hr)
+    {
+        *pResumeType = BOOTSTRAPPER_RESUME_TYPE_NONE;
+        ExitFunction1(hr = S_OK);
+    }
+    ExitOnFailure(hr, "Failed to open registration key.");
+
+    // read Resume value
+    hr = RegReadNumber(hkRegistration, L"Resume", &dwResume);
+    if (E_FILENOTFOUND == hr)
+    {
+        *pResumeType = BOOTSTRAPPER_RESUME_TYPE_INVALID;
+        ExitFunction1(hr = S_OK);
+    }
+    ExitOnFailure(hr, "Failed to read Resume value.");
+
+    switch (dwResume)
+    {
+    case BURN_RESUME_MODE_ACTIVE:
+        // a previous run was interrupted
+        *pResumeType = BOOTSTRAPPER_RESUME_TYPE_INTERRUPTED;
+        break;
+
+    case BURN_RESUME_MODE_SUSPEND:
+        *pResumeType = BOOTSTRAPPER_RESUME_TYPE_SUSPEND;
+        break;
+
+    case BURN_RESUME_MODE_ARP:
+        *pResumeType = BOOTSTRAPPER_RESUME_TYPE_ARP;
+        break;
+
+    case BURN_RESUME_MODE_REBOOT_PENDING:
+        // The volatile pending registry doesn't exist (checked above) which means
+        // the system was successfully restarted.
+        *pResumeType = BOOTSTRAPPER_RESUME_TYPE_REBOOT;
+        break;
+
+    default:
+        // the value stored in the registry is not valid
+        *pResumeType = BOOTSTRAPPER_RESUME_TYPE_INVALID;
+        break;
+    }
+
+LExit:
+    ReleaseRegKey(hkRegistration);
+    ReleaseRegKey(hkRebootRequired);
+    ReleaseStr(sczRebootRequiredKey);
+
+    return hr;
+}
+
+/*******************************************************************
+ RegistrationDetectRelatedBundles - finds the bundles with same 
+  upgrade/detect/addon/patch codes.
+
+*******************************************************************/
+extern "C" HRESULT RegistrationDetectRelatedBundles(
+    __in BURN_REGISTRATION* pRegistration
+    )
+{
+    HRESULT hr = S_OK;
+
+    hr = RelatedBundlesInitializeForScope(TRUE, pRegistration, &pRegistration->relatedBundles);
+    ExitOnFailure(hr, "Failed to initialize per-machine related bundles.");
+
+    hr = RelatedBundlesInitializeForScope(FALSE, pRegistration, &pRegistration->relatedBundles);
+    ExitOnFailure(hr, "Failed to initialize per-user related bundles.");
+
+LExit:
+    return hr;
+}
+
+/*******************************************************************
+ RegistrationSessionBegin - Registers a run session on the system.
+
+*******************************************************************/
+extern "C" HRESULT RegistrationSessionBegin(
+    __in_z LPCWSTR wzEngineWorkingPath,
+    __in BURN_REGISTRATION* pRegistration,
+    __in BURN_VARIABLES* pVariables,
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in DWORD dwRegistrationOptions,
+    __in BURN_DEPENDENCY_REGISTRATION_ACTION dependencyRegistrationAction,
+    __in DWORD64 qwEstimatedSize
+    )
+{
+    HRESULT hr = S_OK;
+    DWORD dwSize = 0;
+    HKEY hkRegistration = NULL;
+    LPWSTR sczPublisher = NULL;
+
+    LogId(REPORT_VERBOSE, MSG_SESSION_BEGIN, pRegistration->sczRegistrationKey, dwRegistrationOptions, LoggingBoolToString(pRegistration->fDisableResume));
+
+    // Cache bundle executable.
+    if (dwRegistrationOptions & BURN_REGISTRATION_ACTION_OPERATIONS_CACHE_BUNDLE)
+    {
+        hr = CacheCompleteBundle(pRegistration->fPerMachine, pRegistration->sczExecutableName, pRegistration->sczId, &pUserExperience->payloads, wzEngineWorkingPath
+#ifdef DEBUG
+                        , pRegistration->sczCacheExecutablePath
+#endif
+                        );
+        ExitOnFailure(hr, "Failed to cache bundle from path: %ls", wzEngineWorkingPath);
+    }
+
+    // create registration key
+    hr = RegCreate(pRegistration->hkRoot, pRegistration->sczRegistrationKey, KEY_WRITE, &hkRegistration);
+    ExitOnFailure(hr, "Failed to create registration key.");
+
+    // Write any ARP values and software tags.
+    if (dwRegistrationOptions & BURN_REGISTRATION_ACTION_OPERATIONS_WRITE_REGISTRATION)
+    {
+        // Upgrade information
+        hr = RegWriteString(hkRegistration, BURN_REGISTRATION_REGISTRY_BUNDLE_CACHE_PATH, pRegistration->sczCacheExecutablePath);
+        ExitOnFailure(hr, "Failed to write %ls value.", BURN_REGISTRATION_REGISTRY_BUNDLE_CACHE_PATH);
+
+        hr = RegWriteStringArray(hkRegistration, BURN_REGISTRATION_REGISTRY_BUNDLE_UPGRADE_CODE, pRegistration->rgsczUpgradeCodes, pRegistration->cUpgradeCodes);
+        ExitOnFailure(hr, "Failed to write %ls value.", BURN_REGISTRATION_REGISTRY_BUNDLE_UPGRADE_CODE);
+
+        hr = RegWriteStringArray(hkRegistration, BURN_REGISTRATION_REGISTRY_BUNDLE_ADDON_CODE, pRegistration->rgsczAddonCodes, pRegistration->cAddonCodes);
+        ExitOnFailure(hr, "Failed to write %ls value.", BURN_REGISTRATION_REGISTRY_BUNDLE_ADDON_CODE);
+
+        hr = RegWriteStringArray(hkRegistration, BURN_REGISTRATION_REGISTRY_BUNDLE_DETECT_CODE, pRegistration->rgsczDetectCodes, pRegistration->cDetectCodes);
+        ExitOnFailure(hr, "Failed to write %ls value.", BURN_REGISTRATION_REGISTRY_BUNDLE_DETECT_CODE);
+
+        hr = RegWriteStringArray(hkRegistration, BURN_REGISTRATION_REGISTRY_BUNDLE_PATCH_CODE, pRegistration->rgsczPatchCodes, pRegistration->cPatchCodes);
+        ExitOnFailure(hr, "Failed to write %ls value.", BURN_REGISTRATION_REGISTRY_BUNDLE_PATCH_CODE);
+
+        hr = RegWriteStringFormatted(hkRegistration, BURN_REGISTRATION_REGISTRY_BUNDLE_VERSION, L"%hu.%hu.%hu.%hu", 
+            static_cast<WORD>(pRegistration->qwVersion >> 48), static_cast<WORD>(pRegistration->qwVersion >> 32), 
+            static_cast<WORD>(pRegistration->qwVersion >> 16), static_cast<WORD>(pRegistration->qwVersion));
+        ExitOnFailure(hr, "Failed to write %ls value.", BURN_REGISTRATION_REGISTRY_BUNDLE_VERSION);
+
+        hr = RegWriteNumber(hkRegistration, REGISTRY_BUNDLE_VERSION_MAJOR, static_cast<WORD>(pRegistration->qwVersion >> 48));
+        ExitOnFailure(hr, "Failed to write %ls value.", REGISTRY_BUNDLE_VERSION_MAJOR);
+
+        hr = RegWriteNumber(hkRegistration, REGISTRY_BUNDLE_VERSION_MINOR, static_cast<WORD>(pRegistration->qwVersion >> 32));
+        ExitOnFailure(hr, "Failed to write %ls value.", REGISTRY_BUNDLE_VERSION_MINOR);
+
+        if (pRegistration->sczProviderKey)
+        {
+            hr = RegWriteString(hkRegistration, BURN_REGISTRATION_REGISTRY_BUNDLE_PROVIDER_KEY, pRegistration->sczProviderKey);
+            ExitOnFailure(hr, "Failed to write %ls value.", BURN_REGISTRATION_REGISTRY_BUNDLE_PROVIDER_KEY);
+        }
+
+        if (pRegistration->sczTag)
+        {
+            hr = RegWriteString(hkRegistration, BURN_REGISTRATION_REGISTRY_BUNDLE_TAG, pRegistration->sczTag);
+            ExitOnFailure(hr, "Failed to write %ls value.", BURN_REGISTRATION_REGISTRY_BUNDLE_TAG);
+        }
+
+        hr = RegWriteStringFormatted(hkRegistration, BURN_REGISTRATION_REGISTRY_ENGINE_VERSION, L"%hs", szVerMajorMinorBuild);
+        ExitOnFailure(hr, "Failed to write %ls value.", BURN_REGISTRATION_REGISTRY_ENGINE_VERSION);
+
+        // DisplayIcon: [path to exe] and ",0" to refer to the first icon in the executable.
+        hr = RegWriteStringFormatted(hkRegistration, REGISTRY_BUNDLE_DISPLAY_ICON, L"%s,0", pRegistration->sczCacheExecutablePath);
+        ExitOnFailure(hr, "Failed to write %ls value.", REGISTRY_BUNDLE_DISPLAY_ICON);
+
+        // update display name
+        hr = UpdateBundleNameRegistration(pRegistration, pVariables, hkRegistration);
+        ExitOnFailure(hr, "Failed to update name and publisher.");
+
+        // DisplayVersion: provided by UI
+        if (pRegistration->sczDisplayVersion)
+        {
+            hr = RegWriteString(hkRegistration, REGISTRY_BUNDLE_DISPLAY_VERSION, pRegistration->sczDisplayVersion);
+            ExitOnFailure(hr, "Failed to write %ls value.", REGISTRY_BUNDLE_DISPLAY_VERSION);
+        }
+
+        // Publisher: provided by UI
+        hr = GetBundleManufacturer(pRegistration, pVariables, &sczPublisher);
+        hr = RegWriteString(hkRegistration, REGISTRY_BUNDLE_PUBLISHER, SUCCEEDED(hr) ? sczPublisher : pRegistration->sczPublisher);
+        ExitOnFailure(hr, "Failed to write %ls value.", REGISTRY_BUNDLE_PUBLISHER);
+
+        // HelpLink: provided by UI
+        if (pRegistration->sczHelpLink)
+        {
+            hr = RegWriteString(hkRegistration, REGISTRY_BUNDLE_HELP_LINK, pRegistration->sczHelpLink);
+            ExitOnFailure(hr, "Failed to write %ls value.", REGISTRY_BUNDLE_HELP_LINK);
+        }
+
+        // HelpTelephone: provided by UI
+        if (pRegistration->sczHelpTelephone)
+        {
+            hr = RegWriteString(hkRegistration, REGISTRY_BUNDLE_HELP_TELEPHONE, pRegistration->sczHelpTelephone);
+            ExitOnFailure(hr, "Failed to write %ls value.", REGISTRY_BUNDLE_HELP_TELEPHONE);
+        }
+
+        // URLInfoAbout, provided by UI
+        if (pRegistration->sczAboutUrl)
+        {
+            hr = RegWriteString(hkRegistration, REGISTRY_BUNDLE_URL_INFO_ABOUT, pRegistration->sczAboutUrl);
+            ExitOnFailure(hr, "Failed to write %ls value.", REGISTRY_BUNDLE_URL_INFO_ABOUT);
+        }
+
+        // URLUpdateInfo, provided by UI
+        if (pRegistration->sczUpdateUrl)
+        {
+            hr = RegWriteString(hkRegistration, REGISTRY_BUNDLE_URL_UPDATE_INFO, pRegistration->sczUpdateUrl);
+            ExitOnFailure(hr, "Failed to write %ls value.", REGISTRY_BUNDLE_URL_UPDATE_INFO);
+        }
+
+        // ParentDisplayName
+        if (pRegistration->sczParentDisplayName)
+        {
+            hr = RegWriteString(hkRegistration, REGISTRY_BUNDLE_PARENT_DISPLAY_NAME, pRegistration->sczParentDisplayName);
+            ExitOnFailure(hr, "Failed to write %ls value.", REGISTRY_BUNDLE_PARENT_DISPLAY_NAME);
+
+            // Need to write the ParentKeyName but can be set to anything.
+            hr = RegWriteString(hkRegistration, REGISTRY_BUNDLE_PARENT_KEY_NAME, pRegistration->sczParentDisplayName);
+            ExitOnFailure(hr, "Failed to write %ls value.", REGISTRY_BUNDLE_PARENT_KEY_NAME);
+        }
+
+        // Comments, provided by UI
+        if (pRegistration->sczComments)
+        {
+            hr = RegWriteString(hkRegistration, REGISTRY_BUNDLE_COMMENTS, pRegistration->sczComments);
+            ExitOnFailure(hr, "Failed to write %ls value.", REGISTRY_BUNDLE_COMMENTS);
+        }
+
+        // Contact, provided by UI
+        if (pRegistration->sczContact)
+        {
+            hr = RegWriteString(hkRegistration, REGISTRY_BUNDLE_CONTACT, pRegistration->sczContact);
+            ExitOnFailure(hr, "Failed to write %ls value.", REGISTRY_BUNDLE_CONTACT);
+        }
+
+        // InstallLocation: provided by UI
+        // TODO: need to figure out what "InstallLocation" means in a chainer. <smile/>
+
+        // NoModify
+        if (BURN_REGISTRATION_MODIFY_DISABLE == pRegistration->modify)
+        {
+            hr = RegWriteNumber(hkRegistration, REGISTRY_BUNDLE_NO_MODIFY, 1);
+            ExitOnFailure(hr, "Failed to write %ls value.", REGISTRY_BUNDLE_NO_MODIFY);
+        }
+        else if (BURN_REGISTRATION_MODIFY_DISABLE_BUTTON != pRegistration->modify) // if support modify (aka: did not disable anything)
+        {
+            // ModifyPath: [path to exe] /modify
+            hr = RegWriteStringFormatted(hkRegistration, REGISTRY_BUNDLE_MODIFY_PATH, L"\"%ls\" /modify", pRegistration->sczCacheExecutablePath);
+            ExitOnFailure(hr, "Failed to write %ls value.", REGISTRY_BUNDLE_MODIFY_PATH);
+
+            // NoElevateOnModify: 1
+            hr = RegWriteNumber(hkRegistration, REGISTRY_BUNDLE_NO_ELEVATE_ON_MODIFY, 1);
+            ExitOnFailure(hr, "Failed to write %ls value.", REGISTRY_BUNDLE_NO_ELEVATE_ON_MODIFY);
+        }
+
+        // NoRemove: should this be allowed?
+        if (pRegistration->fNoRemoveDefined)
+        {
+            hr = RegWriteNumber(hkRegistration, REGISTRY_BUNDLE_NO_REMOVE, (DWORD)pRegistration->fNoRemove);
+            ExitOnFailure(hr, "Failed to write %ls value.", REGISTRY_BUNDLE_NO_REMOVE);
+        }
+
+        // Conditionally hide the ARP entry.
+        if (!pRegistration->fRegisterArp)
+        {
+            hr = RegWriteNumber(hkRegistration, REGISTRY_BUNDLE_SYSTEM_COMPONENT, 1);
+            ExitOnFailure(hr, "Failed to write %ls value.", REGISTRY_BUNDLE_SYSTEM_COMPONENT);
+        }
+
+        // QuietUninstallString: [path to exe] /uninstall /quiet
+        hr = RegWriteStringFormatted(hkRegistration, REGISTRY_BUNDLE_QUIET_UNINSTALL_STRING, L"\"%ls\" /uninstall /quiet", pRegistration->sczCacheExecutablePath);
+        ExitOnFailure(hr, "Failed to write %ls value.", REGISTRY_BUNDLE_QUIET_UNINSTALL_STRING);
+
+        // UninstallString, [path to exe]
+        // If the modify button is to be disabled, we'll add "/modify" to the uninstall string because the button is "Uninstall/Change". Otherwise,
+        // it's just the "Uninstall" button so we add "/uninstall" to make the program just go away.
+        LPCWSTR wzUninstallParameters = (BURN_REGISTRATION_MODIFY_DISABLE_BUTTON == pRegistration->modify) ? L"/modify" : L" /uninstall";
+        hr = RegWriteStringFormatted(hkRegistration, REGISTRY_BUNDLE_UNINSTALL_STRING, L"\"%ls\" %ls", pRegistration->sczCacheExecutablePath, wzUninstallParameters);
+        ExitOnFailure(hr, "Failed to write %ls value.", REGISTRY_BUNDLE_UNINSTALL_STRING);
+
+        if (pRegistration->softwareTags.cSoftwareTags)
+        {
+            hr = WriteSoftwareTags(pRegistration->fPerMachine, &pRegistration->softwareTags);
+            ExitOnFailure(hr, "Failed to write software tags.");
+        }
+
+        // Update registration.
+        if (pRegistration->update.fRegisterUpdate)
+        {
+            hr = WriteUpdateRegistration(pRegistration, pVariables);
+            ExitOnFailure(hr, "Failed to write update registration.");
+        }
+    }
+
+    // Update estimated size.
+    if (dwRegistrationOptions & BURN_REGISTRATION_ACTION_OPERATIONS_UPDATE_SIZE)
+    {
+        qwEstimatedSize /= 1024; // Convert bytes to KB
+        if (0 < qwEstimatedSize)
+        {
+            if (DWORD_MAX < qwEstimatedSize)
+            {
+                // ARP doesn't support QWORDs here
+                dwSize = DWORD_MAX;
+            }
+            else
+            {
+                dwSize = static_cast<DWORD>(qwEstimatedSize);
+            }
+
+            hr = RegWriteNumber(hkRegistration, REGISTRY_BUNDLE_ESTIMATED_SIZE, dwSize);
+            ExitOnFailure(hr, "Failed to write %ls value.", REGISTRY_BUNDLE_ESTIMATED_SIZE);
+        }
+    }
+
+    // Register the bundle dependency key.
+    if (BURN_DEPENDENCY_REGISTRATION_ACTION_REGISTER == dependencyRegistrationAction)
+    {
+        hr = DependencyRegisterBundle(pRegistration);
+        ExitOnFailure(hr, "Failed to register the bundle dependency key.");
+    }
+
+    // update resume mode
+    hr = UpdateResumeMode(pRegistration, hkRegistration, BURN_RESUME_MODE_ACTIVE, FALSE);
+    ExitOnFailure(hr, "Failed to update resume mode.");
+
+LExit:
+    ReleaseStr(sczPublisher);
+    ReleaseRegKey(hkRegistration);
+
+    return hr;
+}
+
+
+/*******************************************************************
+ RegistrationSessionResume - Resumes a previous run session.
+
+*******************************************************************/
+extern "C" HRESULT RegistrationSessionResume(
+    __in BURN_REGISTRATION* pRegistration,
+    __in BURN_VARIABLES* pVariables
+    )
+{
+    HRESULT hr = S_OK;
+    HKEY hkRegistration = NULL;
+
+    // open registration key
+    hr = RegOpen(pRegistration->hkRoot, pRegistration->sczRegistrationKey, KEY_WRITE, &hkRegistration);
+    ExitOnFailure(hr, "Failed to open registration key.");
+
+    // update resume mode
+    hr = UpdateResumeMode(pRegistration, hkRegistration, BURN_RESUME_MODE_ACTIVE, FALSE);
+    ExitOnFailure(hr, "Failed to update resume mode.");
+
+    // update display name
+    hr = UpdateBundleNameRegistration(pRegistration, pVariables, hkRegistration);
+    ExitOnFailure(hr, "Failed to update name and publisher.");
+
+LExit:
+    ReleaseRegKey(hkRegistration);
+
+    return hr;
+}
+
+
+/*******************************************************************
+ RegistrationSessionEnd - Unregisters a run session from the system.
+
+ *******************************************************************/
+extern "C" HRESULT RegistrationSessionEnd(
+    __in BURN_REGISTRATION* pRegistration,
+    __in BURN_RESUME_MODE resumeMode,
+    __in BOOTSTRAPPER_APPLY_RESTART restart,
+    __in BURN_DEPENDENCY_REGISTRATION_ACTION dependencyRegistrationAction
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR sczRebootRequiredKey = NULL;
+    HKEY hkRebootRequired = NULL;
+    HKEY hkRegistration = NULL;
+
+    LogId(REPORT_STANDARD, MSG_SESSION_END, pRegistration->sczRegistrationKey, LoggingResumeModeToString(resumeMode), LoggingRestartToString(restart), LoggingBoolToString(pRegistration->fDisableResume));
+
+    // If a restart is required for any reason, write a volatile registry key to track of
+    // of that fact until the reboot has taken place.
+    if (BOOTSTRAPPER_APPLY_RESTART_NONE != restart)
+    {
+        // We'll write the volatile registry key right next to the bundle ARP registry key
+        // because that's easy. This is all best effort since the worst case just means in
+        // the rare case the user launches the same install again before taking the restart
+        // the BA won't know a restart was still required.
+        hr = StrAllocFormatted(&sczRebootRequiredKey, REGISTRY_REBOOT_PENDING_FORMAT, pRegistration->sczRegistrationKey);
+        if (SUCCEEDED(hr))
+        {
+            hr = RegCreateEx(pRegistration->hkRoot, sczRebootRequiredKey, KEY_WRITE, TRUE, NULL, &hkRebootRequired, NULL);
+        }
+
+        if (FAILED(hr))
+        {
+            ExitTrace(hr, "Failed to write volatile reboot required registry key.");
+            hr = S_OK;
+        }
+    }
+
+    // If no resume mode, then remove the bundle registration.
+    if (BURN_RESUME_MODE_NONE == resumeMode)
+    {
+        // If we just registered the bundle dependency but something went wrong and caused us to not
+        // keep the bundle registration (like rollback) or we are supposed to unregister the bundle
+        // dependency when unregistering the bundle, do so.
+        if (BURN_DEPENDENCY_REGISTRATION_ACTION_REGISTER == dependencyRegistrationAction ||
+            BURN_DEPENDENCY_REGISTRATION_ACTION_UNREGISTER == dependencyRegistrationAction)
+        {
+            // Remove the bundle dependency key.
+            DependencyUnregisterBundle(pRegistration);
+        }
+
+        // Delete update registration key.
+        if (pRegistration->update.fRegisterUpdate)
+        {
+            RemoveUpdateRegistration(pRegistration);
+        }
+
+        RemoveSoftwareTags(pRegistration->fPerMachine, &pRegistration->softwareTags);
+
+        // Delete registration key.
+        hr = RegDelete(pRegistration->hkRoot, pRegistration->sczRegistrationKey, REG_KEY_DEFAULT, FALSE);
+        if (E_FILENOTFOUND != hr)
+        {
+            ExitOnFailure(hr, "Failed to delete registration key: %ls", pRegistration->sczRegistrationKey);
+        }
+
+        CacheRemoveBundle(pRegistration->fPerMachine, pRegistration->sczId);
+    }
+    else // the mode needs to be updated so open the registration key.
+    {
+        // Open registration key.
+        hr = RegOpen(pRegistration->hkRoot, pRegistration->sczRegistrationKey, KEY_WRITE, &hkRegistration);
+        ExitOnFailure(hr, "Failed to open registration key.");
+    }
+
+    // Update resume mode.
+    hr = UpdateResumeMode(pRegistration, hkRegistration, resumeMode, BOOTSTRAPPER_APPLY_RESTART_INITIATED == restart);
+    ExitOnFailure(hr, "Failed to update resume mode.");
+
+LExit:
+    ReleaseRegKey(hkRegistration);
+    ReleaseRegKey(hkRebootRequired);
+    ReleaseStr(sczRebootRequiredKey);
+
+    return hr;
+}
+
+/*******************************************************************
+ RegistrationSaveState - Saves an engine state BLOB for retreval after a resume.
+
+*******************************************************************/
+extern "C" HRESULT RegistrationSaveState(
+    __in BURN_REGISTRATION* pRegistration,
+    __in_bcount(cbBuffer) BYTE* pbBuffer,
+    __in SIZE_T cbBuffer
+    )
+{
+    HRESULT hr = S_OK;
+
+    // write data to file
+    hr = FileWrite(pRegistration->sczStateFile, FILE_ATTRIBUTE_NORMAL, pbBuffer, cbBuffer, NULL);
+    if (E_PATHNOTFOUND == hr)
+    {
+        // TODO: should we log that the bundle's cache folder was not present so the state file wasn't created either?
+        hr = S_OK;
+    }
+    ExitOnFailure(hr, "Failed to write state to file: %ls", pRegistration->sczStateFile);
+
+LExit:
+    return hr;
+}
+
+/*******************************************************************
+ RegistrationLoadState - Loads a previously stored engine state BLOB.
+
+*******************************************************************/
+extern "C" HRESULT RegistrationLoadState(
+    __in BURN_REGISTRATION* pRegistration,
+    __out_bcount(*pcbBuffer) BYTE** ppbBuffer,
+    __out DWORD* pcbBuffer
+    )
+{
+    // read data from file
+    HRESULT hr = FileRead(ppbBuffer, pcbBuffer, pRegistration->sczStateFile);
+    return hr;
+}
+
+/*******************************************************************
+RegistrationGetResumeCommandLine - Gets the resume command line from the registry
+
+*******************************************************************/
+extern "C" HRESULT RegistrationGetResumeCommandLine(
+    __in const BURN_REGISTRATION* pRegistration,
+    __deref_out_z LPWSTR* psczResumeCommandLine
+    )
+{
+    HRESULT hr = S_OK;
+    HKEY hkRegistration = NULL;
+
+    // open registration key
+    hr = RegOpen(pRegistration->hkRoot, pRegistration->sczRegistrationKey, KEY_QUERY_VALUE, &hkRegistration);
+    if (SUCCEEDED(hr))
+    {
+        hr = RegReadString(hkRegistration, REGISTRY_BUNDLE_RESUME_COMMAND_LINE, psczResumeCommandLine);
+    }
+
+    // Not finding the key or value is okay.
+    if (E_FILENOTFOUND == hr || E_PATHNOTFOUND == hr)
+    {
+        hr = S_OK;
+    }
+
+    ReleaseRegKey(hkRegistration);
+
+    return hr;
+}
+
+
+// internal helper functions
+
+static HRESULT ParseSoftwareTagsFromXml(
+    __in IXMLDOMNode* pixnRegistrationNode,
+    __out BURN_SOFTWARE_TAG** prgSoftwareTags,
+    __out DWORD* pcSoftwareTags
+    )
+{
+    HRESULT hr = S_OK;
+    IXMLDOMNodeList* pixnNodes = NULL;
+    IXMLDOMNode* pixnNode = NULL;
+    DWORD cNodes = 0;
+
+    BURN_SOFTWARE_TAG* pSoftwareTags = NULL;
+    BSTR bstrTagXml = NULL;
+
+    // select tag nodes
+    hr = XmlSelectNodes(pixnRegistrationNode, L"SoftwareTag", &pixnNodes);
+    ExitOnFailure(hr, "Failed to select software tag nodes.");
+
+    // get tag node count
+    hr = pixnNodes->get_length((long*)&cNodes);
+    ExitOnFailure(hr, "Failed to get software tag count.");
+
+    if (cNodes)
+    {
+        pSoftwareTags = (BURN_SOFTWARE_TAG*)MemAlloc(sizeof(BURN_SOFTWARE_TAG) * cNodes, TRUE);
+        ExitOnNull(pSoftwareTags, hr, E_OUTOFMEMORY, "Failed to allocate memory for software tag structs.");
+
+        for (DWORD i = 0; i < cNodes; ++i)
+        {
+            BURN_SOFTWARE_TAG* pSoftwareTag = &pSoftwareTags[i];
+
+            hr = XmlNextElement(pixnNodes, &pixnNode, NULL);
+            ExitOnFailure(hr, "Failed to get next node.");
+
+            hr = XmlGetAttributeEx(pixnNode, L"Filename", &pSoftwareTag->sczFilename);
+            ExitOnFailure(hr, "Failed to get @Filename.");
+
+            hr = XmlGetAttributeEx(pixnNode, L"Regid", &pSoftwareTag->sczRegid);
+            ExitOnFailure(hr, "Failed to get @Regid.");
+
+            hr = XmlGetText(pixnNode, &bstrTagXml);
+            ExitOnFailure(hr, "Failed to get SoftwareTag text.");
+
+            hr = StrAnsiAllocString(&pSoftwareTag->sczTag, bstrTagXml, 0, CP_UTF8);
+            ExitOnFailure(hr, "Failed to convert SoftwareTag text to UTF-8");
+
+            // prepare next iteration
+            ReleaseNullBSTR(bstrTagXml);
+            ReleaseNullObject(pixnNode);
+        }
+    }
+
+    *pcSoftwareTags = cNodes;
+    *prgSoftwareTags = pSoftwareTags;
+    pSoftwareTags = NULL;
+
+    hr = S_OK;
+
+LExit:
+    ReleaseBSTR(bstrTagXml);
+    ReleaseObject(pixnNode);
+    ReleaseObject(pixnNodes);
+    ReleaseMem(pSoftwareTags);
+
+    return hr;
+}
+
+static HRESULT SetPaths(
+    __in BURN_REGISTRATION* pRegistration
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR sczCacheDirectory = NULL;
+
+    // save registration key root
+    pRegistration->hkRoot = pRegistration->fPerMachine ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
+
+    // build uninstall registry key path
+    hr = StrAllocFormatted(&pRegistration->sczRegistrationKey, L"%s\\%s", BURN_REGISTRATION_REGISTRY_UNINSTALL_KEY, pRegistration->sczId);
+    ExitOnFailure(hr, "Failed to build uninstall registry key path.");
+
+    // build cache directory
+    hr = CacheGetCompletedPath(pRegistration->fPerMachine, pRegistration->sczId, &sczCacheDirectory);
+    ExitOnFailure(hr, "Failed to build cache directory.");
+
+    // build cached executable path
+    hr = PathConcat(sczCacheDirectory, pRegistration->sczExecutableName, &pRegistration->sczCacheExecutablePath);
+    ExitOnFailure(hr, "Failed to build cached executable path.");
+
+    // build state file path
+    hr = StrAllocFormatted(&pRegistration->sczStateFile, L"%s\\state.rsm", sczCacheDirectory);
+    ExitOnFailure(hr, "Failed to build state file path.");
+
+LExit:
+    ReleaseStr(sczCacheDirectory);
+    return hr;
+}
+
+static HRESULT GetBundleManufacturer(
+    __in BURN_REGISTRATION* pRegistration,
+    __in BURN_VARIABLES* pVariables,
+    __out LPWSTR* psczBundleManufacturer
+    )
+{
+    HRESULT hr = S_OK;
+
+    hr = VariableGetString(pVariables, BURN_BUNDLE_MANUFACTURER, psczBundleManufacturer);
+    if (E_NOTFOUND == hr)
+    {
+        hr = VariableSetLiteralString(pVariables, BURN_BUNDLE_MANUFACTURER, pRegistration->sczPublisher, FALSE);
+        ExitOnFailure(hr, "Failed to set bundle manufacturer.");
+
+        hr = StrAllocString(psczBundleManufacturer, pRegistration->sczPublisher, 0);
+    }
+    ExitOnFailure(hr, "Failed to get bundle manufacturer.");
+
+LExit:
+    return hr;
+}
+
+static HRESULT GetBundleName(
+    __in BURN_REGISTRATION* pRegistration,
+    __in BURN_VARIABLES* pVariables,
+    __out LPWSTR* psczBundleName
+    )
+{
+    HRESULT hr = S_OK;
+
+    hr = VariableGetString(pVariables, BURN_BUNDLE_NAME, psczBundleName);
+    if (E_NOTFOUND == hr)
+    {
+        hr = VariableSetLiteralString(pVariables, BURN_BUNDLE_NAME, pRegistration->sczDisplayName, FALSE);
+        ExitOnFailure(hr, "Failed to set bundle name.");
+
+        hr = StrAllocString(psczBundleName, pRegistration->sczDisplayName, 0);
+    }
+    ExitOnFailure(hr, "Failed to get bundle name.");
+
+LExit:
+    return hr;
+}
+
+static HRESULT UpdateResumeMode(
+    __in BURN_REGISTRATION* pRegistration,
+    __in HKEY hkRegistration,
+    __in BURN_RESUME_MODE resumeMode,
+    __in BOOL fRestartInitiated
+    )
+{
+    HRESULT hr = S_OK;
+    DWORD er = ERROR_SUCCESS;
+    HKEY hkRebootRequired = NULL;
+    HKEY hkRun = NULL;
+    LPWSTR sczResumeCommandLine = NULL;
+    LPCWSTR sczResumeKey = REGISTRY_RUN_ONCE_KEY;
+    OS_VERSION osv = OS_VERSION_UNKNOWN;
+    DWORD dwServicePack = 0;
+
+    LogId(REPORT_STANDARD, MSG_SESSION_UPDATE, pRegistration->sczRegistrationKey, LoggingResumeModeToString(resumeMode), LoggingBoolToString(fRestartInitiated), LoggingBoolToString(pRegistration->fDisableResume));
+
+    // On Windows XP and Server 2003, write the resume information to the Run key
+    // instead of RunOnce. That avoids the problem that driver installation might
+    // trigger RunOnce commands to be executed before the reboot.
+    OsGetVersion(&osv, &dwServicePack);
+    if (osv < OS_VERSION_VISTA)
+    {
+        sczResumeKey = REGISTRY_RUN_KEY;
+    }
+
+    // write resume information
+    if (hkRegistration)
+    {
+        // write Resume value
+        hr = RegWriteNumber(hkRegistration, L"Resume", (DWORD)resumeMode);
+        ExitOnFailure(hr, "Failed to write Resume value.");
+
+        // Write the Installed value *only* when the mode is ARP. This will tell us
+        // that the bundle considers itself "installed" on the machine. Note that we
+        // never change the value to "0" after that. The bundle will be considered
+        // "uninstalled" when all of the registration is removed.
+        if (BURN_RESUME_MODE_ARP == resumeMode)
+        {
+            // Write Installed value.
+            hr = RegWriteNumber(hkRegistration, REGISTRY_BUNDLE_INSTALLED, 1);
+            ExitOnFailure(hr, "Failed to write Installed value.");
+        }
+    }
+
+    // If the engine is active write the run key so we resume if there is an unexpected
+    // power loss. Also, if a restart was initiated in the middle of the chain then
+    // ensure the run key exists (it should since going active would have written it).
+    // Do not write the run key when embedded since the containing bundle
+    // is expected to detect for and restart the embedded bundle.
+    if ((BURN_RESUME_MODE_ACTIVE == resumeMode || fRestartInitiated) && !pRegistration->fDisableResume)
+    {
+        // append RunOnce switch
+        hr = StrAllocFormatted(&sczResumeCommandLine, L"\"%ls\" /%ls", pRegistration->sczCacheExecutablePath, BURN_COMMANDLINE_SWITCH_RUNONCE);
+        ExitOnFailure(hr, "Failed to format resume command line for RunOnce.");
+
+        // write run key
+        hr = RegCreate(pRegistration->hkRoot, sczResumeKey, KEY_WRITE, &hkRun);
+        ExitOnFailure(hr, "Failed to create run key.");
+
+        hr = RegWriteString(hkRun, pRegistration->sczId, sczResumeCommandLine);
+        ExitOnFailure(hr, "Failed to write run key value.");
+
+        hr = RegWriteString(hkRegistration, REGISTRY_BUNDLE_RESUME_COMMAND_LINE, pRegistration->sczResumeCommandLine);
+        ExitOnFailure(hr, "Failed to write resume command line value.");
+    }
+    else // delete run key value
+    {
+        hr = RegOpen(pRegistration->hkRoot, sczResumeKey, KEY_WRITE, &hkRun);
+        if (E_FILENOTFOUND == hr || E_PATHNOTFOUND == hr)
+        {
+            hr = S_OK;
+        }
+        else
+        {
+            ExitOnWin32Error(er, hr, "Failed to open run key.");
+
+            er = ::RegDeleteValueW(hkRun, pRegistration->sczId);
+            if (ERROR_FILE_NOT_FOUND == er)
+            {
+                er = ERROR_SUCCESS;
+            }
+            ExitOnWin32Error(er, hr, "Failed to delete run key value.");
+        }
+
+        if (hkRegistration)
+        {
+            er = ::RegDeleteValueW(hkRegistration, REGISTRY_BUNDLE_RESUME_COMMAND_LINE);
+            if (ERROR_FILE_NOT_FOUND == er)
+            {
+                er = ERROR_SUCCESS;
+            }
+            ExitOnWin32Error(er, hr, "Failed to delete resume command line value.");
+        }
+    }
+
+LExit:
+    ReleaseStr(sczResumeCommandLine);
+    ReleaseRegKey(hkRebootRequired);
+    ReleaseRegKey(hkRun);
+
+    return hr;
+}
+
+static HRESULT ParseRelatedCodes(
+    __in BURN_REGISTRATION* pRegistration,
+    __in IXMLDOMNode* pixnBundle
+    )
+{
+    HRESULT hr = S_OK;
+    IXMLDOMNodeList* pixnNodes = NULL;
+    IXMLDOMNode* pixnElement = NULL;
+    LPWSTR sczAction = NULL;
+    LPWSTR sczId = NULL;
+    DWORD cElements = 0;
+
+    hr = XmlSelectNodes(pixnBundle, L"RelatedBundle", &pixnNodes);
+    ExitOnFailure(hr, "Failed to get RelatedBundle nodes");
+
+    hr = pixnNodes->get_length((long*)&cElements);
+    ExitOnFailure(hr, "Failed to get RelatedBundle element count.");
+
+    for (DWORD i = 0; i < cElements; ++i)
+    {
+        hr = XmlNextElement(pixnNodes, &pixnElement, NULL);
+        ExitOnFailure(hr, "Failed to get next RelatedBundle element.");
+
+        hr = XmlGetAttributeEx(pixnElement, L"Action", &sczAction);
+        ExitOnFailure(hr, "Failed to get @Action.");
+
+        hr = XmlGetAttributeEx(pixnElement, L"Id", &sczId);
+        ExitOnFailure(hr, "Failed to get @Id.");
+
+        if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, sczAction, -1, L"Detect", -1))
+        {
+            hr = MemEnsureArraySize(reinterpret_cast<LPVOID*>(&pRegistration->rgsczDetectCodes), pRegistration->cDetectCodes + 1, sizeof(LPWSTR), 5);
+            ExitOnFailure(hr, "Failed to resize Detect code array in registration");
+
+            pRegistration->rgsczDetectCodes[pRegistration->cDetectCodes] = sczId;
+            sczId = NULL;
+            ++pRegistration->cDetectCodes;
+        }
+        else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, sczAction, -1, L"Upgrade", -1))
+        {
+            hr = MemEnsureArraySize(reinterpret_cast<LPVOID*>(&pRegistration->rgsczUpgradeCodes), pRegistration->cUpgradeCodes + 1, sizeof(LPWSTR), 5);
+            ExitOnFailure(hr, "Failed to resize Upgrade code array in registration");
+
+            pRegistration->rgsczUpgradeCodes[pRegistration->cUpgradeCodes] = sczId;
+            sczId = NULL;
+            ++pRegistration->cUpgradeCodes;
+        }
+        else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, sczAction, -1, L"Addon", -1))
+        {
+            hr = MemEnsureArraySize(reinterpret_cast<LPVOID*>(&pRegistration->rgsczAddonCodes), pRegistration->cAddonCodes + 1, sizeof(LPWSTR), 5);
+            ExitOnFailure(hr, "Failed to resize Addon code array in registration");
+
+            pRegistration->rgsczAddonCodes[pRegistration->cAddonCodes] = sczId;
+            sczId = NULL;
+            ++pRegistration->cAddonCodes;
+        }
+        else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, sczAction, -1, L"Patch", -1))
+        {
+            hr = MemEnsureArraySize(reinterpret_cast<LPVOID*>(&pRegistration->rgsczPatchCodes), pRegistration->cPatchCodes + 1, sizeof(LPWSTR), 5);
+            ExitOnFailure(hr, "Failed to resize Patch code array in registration");
+
+            pRegistration->rgsczPatchCodes[pRegistration->cPatchCodes] = sczId;
+            sczId = NULL;
+            ++pRegistration->cPatchCodes;
+        }
+        else
+        {
+            hr = E_INVALIDARG;
+            ExitOnFailure(hr, "Invalid value for @Action: %ls", sczAction);
+        }
+    }
+
+LExit:
+    ReleaseObject(pixnNodes);
+    ReleaseObject(pixnElement);
+    ReleaseStr(sczAction);
+    ReleaseStr(sczId);
+
+    return hr;
+}
+
+static HRESULT FormatUpdateRegistrationKey(
+    __in BURN_REGISTRATION* pRegistration,
+    __out_z LPWSTR* psczKey
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR sczKey = NULL;
+
+    hr = StrAllocFormatted(&sczKey, L"SOFTWARE\\%ls\\Updates\\", pRegistration->update.sczManufacturer);
+    ExitOnFailure(hr, "Failed to format the key path for update registration.");
+
+    if (pRegistration->update.sczProductFamily)
+    {
+        hr = StrAllocFormatted(&sczKey, L"%ls%ls\\", sczKey, pRegistration->update.sczProductFamily);
+        ExitOnFailure(hr, "Failed to format the key path for update registration.");
+    }
+
+    hr = StrAllocConcat(&sczKey, pRegistration->update.sczName, 0);
+    ExitOnFailure(hr, "Failed to format the key path for update registration.");
+
+    *psczKey = sczKey;
+    sczKey = NULL;
+
+LExit:
+    ReleaseStr(sczKey);
+
+    return hr;
+}
+
+static HRESULT WriteSoftwareTags(
+    __in BOOL fPerMachine,
+    __in BURN_SOFTWARE_TAGS* pSoftwareTags
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR sczRootFolder = NULL;
+    LPWSTR sczRegidFolder = NULL;
+    LPWSTR sczPath = NULL;
+
+    hr = PathGetKnownFolder(fPerMachine ? CSIDL_COMMON_APPDATA : CSIDL_LOCAL_APPDATA, &sczRootFolder);
+    ExitOnFailure(hr, "Failed to find local %hs appdata directory.", fPerMachine ? "per-machine" : "per-user");
+
+    for (DWORD iTag = 0; iTag < pSoftwareTags->cSoftwareTags; ++iTag)
+    {
+        BURN_SOFTWARE_TAG* pSoftwareTag = pSoftwareTags->rgSoftwareTags + iTag;
+
+        hr = PathConcat(sczRootFolder, pSoftwareTag->sczRegid, &sczRegidFolder);
+        ExitOnFailure(hr, "Failed to allocate regid folder path.");
+
+        hr = PathConcat(sczRegidFolder, pSoftwareTag->sczFilename, &sczPath);
+        ExitOnFailure(hr, "Failed to allocate regid folder path.");
+
+        hr = DirEnsureExists(sczRegidFolder, NULL);
+        ExitOnFailure(hr, "Failed to create regid folder: %ls", sczRegidFolder);
+
+        hr = FileWrite(sczPath, FILE_ATTRIBUTE_NORMAL, reinterpret_cast<LPBYTE>(pSoftwareTag->sczTag), lstrlenA(pSoftwareTag->sczTag), NULL);
+        ExitOnFailure(hr, "Failed to write tag xml to file: %ls", sczPath);
+    }
+
+LExit:
+    ReleaseStr(sczPath);
+    ReleaseStr(sczRegidFolder);
+    ReleaseStr(sczRootFolder);
+
+    return hr;
+}
+
+static HRESULT RemoveSoftwareTags(
+    __in BOOL fPerMachine,
+    __in BURN_SOFTWARE_TAGS* pSoftwareTags
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR sczRootFolder = NULL;
+    LPWSTR sczRegidFolder = NULL;
+    LPWSTR sczPath = NULL;
+
+    hr = PathGetKnownFolder(fPerMachine ? CSIDL_COMMON_APPDATA : CSIDL_LOCAL_APPDATA, &sczRootFolder);
+    ExitOnFailure(hr, "Failed to find local %hs appdata directory.", fPerMachine ? "per-machine" : "per-user");
+
+    for (DWORD iTag = 0; iTag < pSoftwareTags->cSoftwareTags; ++iTag)
+    {
+        BURN_SOFTWARE_TAG* pSoftwareTag = pSoftwareTags->rgSoftwareTags + iTag;
+
+        hr = PathConcat(sczRootFolder, pSoftwareTag->sczRegid, &sczRegidFolder);
+        ExitOnFailure(hr, "Failed to allocate regid folder path.");
+
+        hr = PathConcat(sczRegidFolder, pSoftwareTag->sczFilename, &sczPath);
+        ExitOnFailure(hr, "Failed to allocate regid folder path.");
+
+        // Best effort to delete the software tag file and the regid folder.
+        FileEnsureDelete(sczPath);
+
+        ::RemoveDirectoryW(sczRegidFolder);
+    }
+
+LExit:
+    ReleaseStr(sczPath);
+    ReleaseStr(sczRegidFolder);
+    ReleaseStr(sczRootFolder);
+
+    return hr;
+}
+
+static HRESULT WriteUpdateRegistration(
+    __in BURN_REGISTRATION* pRegistration,
+    __in BURN_VARIABLES* pVariables
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR sczKey = NULL;
+    HKEY hkKey = NULL;
+
+    hr = FormatUpdateRegistrationKey(pRegistration, &sczKey);
+    ExitOnFailure(hr, "Failed to get the formatted key path for update registration.");
+
+    hr = RegCreate(pRegistration->hkRoot, sczKey, KEY_WRITE, &hkKey);
+    ExitOnFailure(hr, "Failed to create the key for update registration.");
+
+    hr = RegWriteString(hkKey, L"ThisVersionInstalled", L"Y");
+    ExitOnFailure(hr, "Failed to write %ls value.", L"ThisVersionInstalled");
+
+    hr = RegWriteString(hkKey, L"PackageName", pRegistration->sczDisplayName);
+    ExitOnFailure(hr, "Failed to write %ls value.", L"PackageName");
+
+    hr = RegWriteString(hkKey, L"PackageVersion", pRegistration->sczDisplayVersion);
+    ExitOnFailure(hr, "Failed to write %ls value.", L"PackageVersion");
+
+    hr = RegWriteString(hkKey, L"Publisher", pRegistration->sczPublisher);
+    ExitOnFailure(hr, "Failed to write %ls value.", L"Publisher");
+
+    if (pRegistration->update.sczDepartment)
+    {
+        hr = RegWriteString(hkKey, L"PublishingGroup", pRegistration->update.sczDepartment);
+        ExitOnFailure(hr, "Failed to write %ls value.", L"PublishingGroup");
+    }
+
+    hr = RegWriteString(hkKey, L"ReleaseType", pRegistration->update.sczClassification);
+    ExitOnFailure(hr, "Failed to write %ls value.", L"ReleaseType");
+
+    hr = RegWriteStringVariable(hkKey, pVariables, VARIABLE_LOGONUSER, L"InstalledBy");
+    ExitOnFailure(hr, "Failed to write %ls value.", L"InstalledBy");
+
+    hr = RegWriteStringVariable(hkKey, pVariables, VARIABLE_DATE, L"InstalledDate");
+    ExitOnFailure(hr, "Failed to write %ls value.", L"InstalledDate");
+
+    hr = RegWriteStringVariable(hkKey, pVariables, VARIABLE_INSTALLERNAME, L"InstallerName");
+    ExitOnFailure(hr, "Failed to write %ls value.", L"InstallerName");
+
+    hr = RegWriteStringVariable(hkKey, pVariables, VARIABLE_INSTALLERVERSION, L"InstallerVersion");
+    ExitOnFailure(hr, "Failed to write %ls value.", L"InstallerVersion");
+
+LExit:
+    ReleaseRegKey(hkKey);
+    ReleaseStr(sczKey);
+
+    return hr;
+}
+
+static HRESULT RemoveUpdateRegistration(
+    __in BURN_REGISTRATION* pRegistration
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR sczKey = NULL;
+    LPWSTR sczPackageVersion = NULL;
+    HKEY hkKey = NULL;
+    BOOL fDeleteRegKey = TRUE;
+
+    hr = FormatUpdateRegistrationKey(pRegistration, &sczKey);
+    ExitOnFailure(hr, "Failed to format key for update registration.");
+
+    // Only delete if the uninstalling bundle's PackageVersion is the same as the
+    // PackageVersion in the update registration key.
+    // This is to support build to build upgrades
+    hr = RegOpen(pRegistration->hkRoot, sczKey, KEY_QUERY_VALUE, &hkKey);
+    if (SUCCEEDED(hr))
+    {
+        hr = RegReadString(hkKey, L"PackageVersion", &sczPackageVersion);
+        if (SUCCEEDED(hr))
+        {
+            if (CSTR_EQUAL != ::CompareStringW(LOCALE_INVARIANT, 0, sczPackageVersion, -1, pRegistration->sczDisplayVersion, -1))
+            {
+                fDeleteRegKey = FALSE;
+            }
+        }
+        ReleaseRegKey(hkKey);
+    }
+
+    // Unable to open the key or read the value is okay.
+    hr = S_OK;
+
+    if (fDeleteRegKey)
+    {
+        hr = RegDelete(pRegistration->hkRoot, sczKey, REG_KEY_DEFAULT, FALSE);
+        if (E_FILENOTFOUND != hr)
+        {
+            ExitOnFailure(hr, "Failed to remove update registration key: %ls", sczKey);
+        }
+    }
+
+LExit:
+    ReleaseStr(sczPackageVersion);
+    ReleaseStr(sczKey);
+
+    return hr;
+}
+
+static HRESULT RegWriteStringVariable(
+    __in HKEY hk,
+    __in BURN_VARIABLES* pVariables,
+    __in LPCWSTR wzVariable,
+    __in LPCWSTR wzName
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR sczValue = NULL;
+
+    hr = VariableGetString(pVariables, wzVariable, &sczValue);
+    ExitOnFailure(hr, "Failed to get the %ls variable.", wzVariable);
+
+    hr = RegWriteString(hk, wzName, sczValue);
+    ExitOnFailure(hr, "Failed to write %ls value.", wzName);
+
+LExit:
+    StrSecureZeroFreeString(sczValue);
+
+    return hr;
+}
+
+static HRESULT UpdateBundleNameRegistration(
+    __in BURN_REGISTRATION* pRegistration,
+    __in BURN_VARIABLES* pVariables,
+    __in HKEY hkRegistration
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR sczDisplayName = NULL;
+
+    // DisplayName: provided by UI
+    hr = GetBundleName(pRegistration, pVariables, &sczDisplayName);
+    hr = RegWriteString(hkRegistration, BURN_REGISTRATION_REGISTRY_BUNDLE_DISPLAY_NAME, SUCCEEDED(hr) ? sczDisplayName : pRegistration->sczDisplayName);
+    ExitOnFailure(hr, "Failed to write %ls value.", BURN_REGISTRATION_REGISTRY_BUNDLE_DISPLAY_NAME);
+
+LExit:
+    ReleaseStr(sczDisplayName);
+
+    return hr;
+}
diff --git a/src/engine/registration.h b/src/engine/registration.h
new file mode 100644
index 00000000..c830a06d
--- /dev/null
+++ b/src/engine/registration.h
@@ -0,0 +1,214 @@
+#pragma once
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+
+enum BURN_MODE;
+enum BURN_DEPENDENCY_REGISTRATION_ACTION;
+struct _BURN_LOGGING;
+typedef _BURN_LOGGING BURN_LOGGING;
+
+// constants
+
+const LPCWSTR BURN_REGISTRATION_REGISTRY_UNINSTALL_KEY = L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall";
+const LPCWSTR BURN_REGISTRATION_REGISTRY_BUNDLE_CACHE_PATH = L"BundleCachePath";
+const LPCWSTR BURN_REGISTRATION_REGISTRY_BUNDLE_ADDON_CODE = L"BundleAddonCode";
+const LPCWSTR BURN_REGISTRATION_REGISTRY_BUNDLE_DETECT_CODE = L"BundleDetectCode";
+const LPCWSTR BURN_REGISTRATION_REGISTRY_BUNDLE_PATCH_CODE = L"BundlePatchCode";
+const LPCWSTR BURN_REGISTRATION_REGISTRY_BUNDLE_UPGRADE_CODE = L"BundleUpgradeCode";
+const LPCWSTR BURN_REGISTRATION_REGISTRY_BUNDLE_DISPLAY_NAME = L"DisplayName";
+const LPCWSTR BURN_REGISTRATION_REGISTRY_BUNDLE_VERSION = L"BundleVersion";
+const LPCWSTR BURN_REGISTRATION_REGISTRY_ENGINE_VERSION = L"EngineVersion";
+const LPCWSTR BURN_REGISTRATION_REGISTRY_BUNDLE_PROVIDER_KEY = L"BundleProviderKey";
+const LPCWSTR BURN_REGISTRATION_REGISTRY_BUNDLE_TAG = L"BundleTag";
+
+enum BURN_RESUME_MODE
+{
+    BURN_RESUME_MODE_NONE,
+    BURN_RESUME_MODE_ACTIVE,
+    BURN_RESUME_MODE_SUSPEND,
+    BURN_RESUME_MODE_ARP,
+    BURN_RESUME_MODE_REBOOT_PENDING,
+};
+
+enum BURN_REGISTRATION_MODIFY_TYPE
+{
+    BURN_REGISTRATION_MODIFY_ENABLED,
+    BURN_REGISTRATION_MODIFY_DISABLE,
+    BURN_REGISTRATION_MODIFY_DISABLE_BUTTON,
+};
+
+
+// structs
+
+typedef struct _BURN_UPDATE_REGISTRATION
+{
+    BOOL fRegisterUpdate;
+    LPWSTR sczManufacturer;
+    LPWSTR sczDepartment;
+    LPWSTR sczProductFamily;
+    LPWSTR sczName;
+    LPWSTR sczClassification;
+} BURN_UPDATE_REGISTRATION;
+
+typedef struct _BURN_RELATED_BUNDLE
+{
+    BOOTSTRAPPER_RELATION_TYPE relationType;
+
+    DWORD64 qwVersion;
+    LPWSTR sczTag;
+
+    BURN_PACKAGE package;
+} BURN_RELATED_BUNDLE;
+
+typedef struct _BURN_RELATED_BUNDLES
+{
+    BURN_RELATED_BUNDLE* rgRelatedBundles;
+    DWORD cRelatedBundles;
+} BURN_RELATED_BUNDLES;
+
+typedef struct _BURN_SOFTWARE_TAG
+{
+    LPWSTR sczFilename;
+    LPWSTR sczRegid;
+    LPSTR sczTag;
+} BURN_SOFTWARE_TAG;
+
+typedef struct _BURN_SOFTWARE_TAGS
+{
+    BURN_SOFTWARE_TAG* rgSoftwareTags;
+    DWORD cSoftwareTags;
+} BURN_SOFTWARE_TAGS;
+
+typedef struct _BURN_REGISTRATION
+{
+    BOOL fPerMachine;
+    BOOL fRegisterArp;
+    BOOL fDisableResume;
+    BOOL fInstalled;
+    LPWSTR sczId;
+    LPWSTR sczTag;
+
+    LPWSTR *rgsczDetectCodes;
+    DWORD cDetectCodes;
+
+    LPWSTR *rgsczUpgradeCodes;
+    DWORD cUpgradeCodes;
+
+    LPWSTR *rgsczAddonCodes;
+    DWORD cAddonCodes;
+
+    LPWSTR *rgsczPatchCodes;
+    DWORD cPatchCodes;
+
+    DWORD64 qwVersion;
+    LPWSTR sczActiveParent;
+    LPWSTR sczProviderKey;
+    LPWSTR sczExecutableName;
+
+    // paths
+    HKEY hkRoot;
+    LPWSTR sczRegistrationKey;
+    LPWSTR sczCacheExecutablePath;
+    LPWSTR sczResumeCommandLine;
+    LPWSTR sczStateFile;
+
+    // ARP registration
+    LPWSTR sczDisplayName;
+    LPWSTR sczDisplayVersion;
+    LPWSTR sczPublisher;
+    LPWSTR sczHelpLink;
+    LPWSTR sczHelpTelephone;
+    LPWSTR sczAboutUrl;
+    LPWSTR sczUpdateUrl;
+    LPWSTR sczParentDisplayName;
+    LPWSTR sczComments;
+    //LPWSTR sczReadme; // TODO: this would be a file path
+    LPWSTR sczContact;
+    //DWORD64 qwEstimatedSize; // TODO: size should come from disk cost calculation
+    BURN_REGISTRATION_MODIFY_TYPE modify;
+    BOOL fNoRemoveDefined;
+    BOOL fNoRemove;
+
+    BURN_SOFTWARE_TAGS softwareTags;
+
+    // Update registration
+    BURN_UPDATE_REGISTRATION update;
+
+    // Only valid after detect.
+    BURN_RELATED_BUNDLES relatedBundles;
+
+    LPWSTR sczDetectedProviderKeyBundleId;
+    LPWSTR sczAncestors;
+
+    BOOL fEnabledForwardCompatibleBundle;
+    BURN_PACKAGE forwardCompatibleBundle;
+} BURN_REGISTRATION;
+
+
+// functions
+
+HRESULT RegistrationParseFromXml(
+    __in BURN_REGISTRATION* pRegistration,
+    __in IXMLDOMNode* pixnBundle
+    );
+void RegistrationUninitialize(
+    __in BURN_REGISTRATION* pRegistration
+    );
+HRESULT RegistrationSetVariables(
+    __in BURN_REGISTRATION* pRegistration,
+    __in BURN_VARIABLES* pVariables
+    );
+HRESULT RegistrationDetectInstalled(
+    __in BURN_REGISTRATION* pRegistration,
+    __out BOOL* pfInstalled
+    );
+HRESULT RegistrationDetectResumeType(
+    __in BURN_REGISTRATION* pRegistration,
+    __out BOOTSTRAPPER_RESUME_TYPE* pResumeType
+    );
+HRESULT RegistrationDetectRelatedBundles(
+    __in BURN_REGISTRATION* pRegistration
+    );
+HRESULT RegistrationSessionBegin(
+    __in_z LPCWSTR wzEngineWorkingPath,
+    __in BURN_REGISTRATION* pRegistration,
+    __in BURN_VARIABLES* pVariables,
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in DWORD dwRegistrationOptions,
+    __in BURN_DEPENDENCY_REGISTRATION_ACTION dependencyRegistrationAction,
+    __in DWORD64 qwEstimatedSize
+    );
+HRESULT RegistrationSessionResume(
+    __in BURN_REGISTRATION* pRegistration,
+    __in BURN_VARIABLES* pVariables
+    );
+HRESULT RegistrationSessionEnd(
+    __in BURN_REGISTRATION* pRegistration,
+    __in BURN_RESUME_MODE resumeMode,
+    __in BOOTSTRAPPER_APPLY_RESTART restart,
+    __in BURN_DEPENDENCY_REGISTRATION_ACTION dependencyRegistrationAction
+    );
+HRESULT RegistrationSaveState(
+    __in BURN_REGISTRATION* pRegistration,
+    __in_bcount_opt(cbBuffer) BYTE* pbBuffer,
+    __in_opt DWORD cbBuffer
+    );
+HRESULT RegistrationLoadState(
+    __in BURN_REGISTRATION* pRegistration,
+    __out_bcount(*pcbBuffer) BYTE** ppbBuffer,
+    __out DWORD* pcbBuffer
+    );
+HRESULT RegistrationGetResumeCommandLine(
+    __in const BURN_REGISTRATION* pRegistration,
+    __deref_out_z LPWSTR* psczResumeCommandLine
+    );
+
+
+#if defined(__cplusplus)
+}
+#endif
diff --git a/src/engine/relatedbundle.cpp b/src/engine/relatedbundle.cpp
new file mode 100644
index 00000000..87794177
--- /dev/null
+++ b/src/engine/relatedbundle.cpp
@@ -0,0 +1,457 @@
+// 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.
+
+#include "precomp.h"
+
+// internal function declarations
+
+static HRESULT LoadIfRelatedBundle(
+    __in BOOL fPerMachine,
+    __in HKEY hkUninstallKey,
+    __in_z LPCWSTR sczRelatedBundleId,
+    __in BURN_REGISTRATION* pRegistration,
+    __in BURN_RELATED_BUNDLES* pRelatedBundles
+    );
+static HRESULT DetermineRelationType(
+    __in HKEY hkBundleId,
+    __in BURN_REGISTRATION* pRegistration,
+    __out BOOTSTRAPPER_RELATION_TYPE* pRelationType
+    );
+static HRESULT LoadRelatedBundleFromKey(
+    __in_z LPCWSTR wzRelatedBundleId,
+    __in HKEY hkBundleId,
+    __in BOOL fPerMachine,
+    __in BOOTSTRAPPER_RELATION_TYPE relationType,
+    __inout BURN_RELATED_BUNDLE *pRelatedBundle
+    );
+
+
+// function definitions
+
+extern "C" HRESULT RelatedBundlesInitializeForScope(
+    __in BOOL fPerMachine,
+    __in BURN_REGISTRATION* pRegistration,
+    __in BURN_RELATED_BUNDLES* pRelatedBundles
+    )
+{
+    HRESULT hr = S_OK;
+    HKEY hkRoot = fPerMachine ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
+    HKEY hkUninstallKey = NULL;
+    LPWSTR sczRelatedBundleId = NULL;
+
+    hr = RegOpen(hkRoot, BURN_REGISTRATION_REGISTRY_UNINSTALL_KEY, KEY_READ, &hkUninstallKey);
+    if (HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND) == hr || HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) == hr)
+    {
+        ExitFunction1(hr = S_OK);
+    }
+    ExitOnFailure(hr, "Failed to open uninstall registry key.");
+
+    for (DWORD dwIndex = 0; /* exit via break below */; ++dwIndex)
+    {
+        hr = RegKeyEnum(hkUninstallKey, dwIndex, &sczRelatedBundleId);
+        if (E_NOMOREITEMS == hr)
+        {
+            hr = S_OK;
+            break;
+        }
+        ExitOnFailure(hr, "Failed to enumerate uninstall key for related bundles.");
+
+        // If we did not find our bundle id, try to load the subkey as a related bundle.
+        if (CSTR_EQUAL != ::CompareStringW(LOCALE_NEUTRAL, NORM_IGNORECASE, sczRelatedBundleId, -1, pRegistration->sczId, -1))
+        {
+            // Ignore failures here since we'll often find products that aren't actually
+            // related bundles (or even bundles at all).
+            HRESULT hrRelatedBundle = LoadIfRelatedBundle(fPerMachine, hkUninstallKey, sczRelatedBundleId, pRegistration, pRelatedBundles);
+            UNREFERENCED_PARAMETER(hrRelatedBundle);
+        }
+    }
+
+LExit:
+    ReleaseStr(sczRelatedBundleId);
+    ReleaseRegKey(hkUninstallKey);
+
+    return hr;
+}
+
+extern "C" void RelatedBundlesUninitialize(
+    __in BURN_RELATED_BUNDLES* pRelatedBundles
+    )
+{
+    if (pRelatedBundles->rgRelatedBundles)
+    {
+        for (DWORD i = 0; i < pRelatedBundles->cRelatedBundles; ++i)
+        {
+            PackageUninitialize(&pRelatedBundles->rgRelatedBundles[i].package);
+            ReleaseStr(pRelatedBundles->rgRelatedBundles[i].sczTag);
+        }
+
+        MemFree(pRelatedBundles->rgRelatedBundles);
+    }
+
+    memset(pRelatedBundles, 0, sizeof(BURN_RELATED_BUNDLES));
+}
+
+
+// internal helper functions
+
+static HRESULT LoadIfRelatedBundle(
+    __in BOOL fPerMachine,
+    __in HKEY hkUninstallKey,
+    __in_z LPCWSTR sczRelatedBundleId,
+    __in BURN_REGISTRATION* pRegistration,
+    __in BURN_RELATED_BUNDLES* pRelatedBundles
+    )
+{
+    HRESULT hr = S_OK;
+    HKEY hkBundleId = NULL;
+    BOOTSTRAPPER_RELATION_TYPE relationType = BOOTSTRAPPER_RELATION_NONE;
+
+    hr = RegOpen(hkUninstallKey, sczRelatedBundleId, KEY_READ, &hkBundleId);
+    ExitOnFailure(hr, "Failed to open uninstall key for potential related bundle: %ls", sczRelatedBundleId);
+
+    hr = DetermineRelationType(hkBundleId, pRegistration, &relationType);
+    if (FAILED(hr) || BOOTSTRAPPER_RELATION_NONE == relationType)
+    {
+        // Must not be a related bundle.
+        hr = E_NOTFOUND;
+    }
+    else // load the related bundle.
+    {
+        hr = MemEnsureArraySize(reinterpret_cast<LPVOID*>(&pRelatedBundles->rgRelatedBundles), pRelatedBundles->cRelatedBundles + 1, sizeof(BURN_RELATED_BUNDLE), 5);
+        ExitOnFailure(hr, "Failed to ensure there is space for related bundles.");
+
+        BURN_RELATED_BUNDLE* pRelatedBundle = pRelatedBundles->rgRelatedBundles + pRelatedBundles->cRelatedBundles;
+
+        hr = LoadRelatedBundleFromKey(sczRelatedBundleId, hkBundleId, fPerMachine, relationType, pRelatedBundle);
+        ExitOnFailure(hr, "Failed to initialize package from related bundle id: %ls", sczRelatedBundleId);
+
+        ++pRelatedBundles->cRelatedBundles;
+    }
+
+LExit:
+    ReleaseRegKey(hkBundleId);
+
+    return hr;
+}
+
+static HRESULT DetermineRelationType(
+    __in HKEY hkBundleId,
+    __in BURN_REGISTRATION* pRegistration,
+    __out BOOTSTRAPPER_RELATION_TYPE* pRelationType
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR* rgsczUpgradeCodes = NULL;
+    DWORD cUpgradeCodes = 0;
+    STRINGDICT_HANDLE sdUpgradeCodes = NULL;
+    LPWSTR* rgsczAddonCodes = NULL;
+    DWORD cAddonCodes = 0;
+    STRINGDICT_HANDLE sdAddonCodes = NULL;
+    LPWSTR* rgsczDetectCodes = NULL;
+    DWORD cDetectCodes = 0;
+    STRINGDICT_HANDLE sdDetectCodes = NULL;
+    LPWSTR* rgsczPatchCodes = NULL;
+    DWORD cPatchCodes = 0;
+    STRINGDICT_HANDLE sdPatchCodes = NULL;
+
+    *pRelationType = BOOTSTRAPPER_RELATION_NONE;
+
+    // All remaining operations should treat all related bundles as non-vital.
+    hr = RegReadStringArray(hkBundleId, BURN_REGISTRATION_REGISTRY_BUNDLE_UPGRADE_CODE, &rgsczUpgradeCodes, &cUpgradeCodes);
+    if (HRESULT_FROM_WIN32(ERROR_INVALID_DATATYPE) == hr)
+    {
+        TraceError(hr, "Failed to read upgrade codes as REG_MULTI_SZ. Trying again as REG_SZ in case of older bundles.");
+
+        rgsczUpgradeCodes = reinterpret_cast<LPWSTR*>(MemAlloc(sizeof(LPWSTR), TRUE));
+        ExitOnNull(rgsczUpgradeCodes, hr, E_OUTOFMEMORY, "Failed to allocate list for a single upgrade code from older bundle.");
+
+        hr = RegReadString(hkBundleId, BURN_REGISTRATION_REGISTRY_BUNDLE_UPGRADE_CODE, &rgsczUpgradeCodes[0]);
+        if (SUCCEEDED(hr))
+        {
+            cUpgradeCodes = 1;
+        }
+    }
+
+    // Compare upgrade codes.
+    if (SUCCEEDED(hr))
+    {
+        hr = DictCreateStringListFromArray(&sdUpgradeCodes, rgsczUpgradeCodes, cUpgradeCodes, DICT_FLAG_CASEINSENSITIVE);
+        ExitOnFailure(hr, "Failed to create string dictionary for %hs.", "upgrade codes");
+
+        // Upgrade relationship: when their upgrade codes match our upgrade codes.
+        hr = DictCompareStringListToArray(sdUpgradeCodes, const_cast<LPCWSTR*>(pRegistration->rgsczUpgradeCodes), pRegistration->cUpgradeCodes);
+        if (HRESULT_FROM_WIN32(ERROR_NO_MATCH) == hr)
+        {
+            hr = S_OK;
+        }
+        else
+        {
+            ExitOnFailure(hr, "Failed to do array search for upgrade code match.");
+
+            *pRelationType = BOOTSTRAPPER_RELATION_UPGRADE;
+            ExitFunction();
+        }
+
+        // Detect relationship: when their upgrade codes match our detect codes.
+        hr = DictCompareStringListToArray(sdUpgradeCodes, const_cast<LPCWSTR*>(pRegistration->rgsczDetectCodes), pRegistration->cDetectCodes);
+        if (HRESULT_FROM_WIN32(ERROR_NO_MATCH) == hr)
+        {
+            hr = S_OK;
+        }
+        else
+        {
+            ExitOnFailure(hr, "Failed to do array search for detect code match.");
+
+            *pRelationType = BOOTSTRAPPER_RELATION_DETECT;
+            ExitFunction();
+        }
+
+        // Dependent relationship: when their upgrade codes match our addon codes.
+        hr = DictCompareStringListToArray(sdUpgradeCodes, const_cast<LPCWSTR*>(pRegistration->rgsczAddonCodes), pRegistration->cAddonCodes);
+        if (HRESULT_FROM_WIN32(ERROR_NO_MATCH) == hr)
+        {
+            hr = S_OK;
+        }
+        else
+        {
+            ExitOnFailure(hr, "Failed to do array search for addon code match.");
+
+            *pRelationType = BOOTSTRAPPER_RELATION_DEPENDENT;
+            ExitFunction();
+        }
+
+        // Dependent relationship: when their upgrade codes match our patch codes.
+        hr = DictCompareStringListToArray(sdUpgradeCodes, const_cast<LPCWSTR*>(pRegistration->rgsczPatchCodes), pRegistration->cPatchCodes);
+        if (HRESULT_FROM_WIN32(ERROR_NO_MATCH) == hr)
+        {
+            hr = S_OK;
+        }
+        else
+        {
+            ExitOnFailure(hr, "Failed to do array search for addon code match.");
+
+            *pRelationType = BOOTSTRAPPER_RELATION_DEPENDENT;
+            ExitFunction();
+        }
+
+        ReleaseNullDict(sdUpgradeCodes);
+        ReleaseNullStrArray(rgsczUpgradeCodes, cUpgradeCodes);
+    }
+
+    // Compare addon codes.
+    hr = RegReadStringArray(hkBundleId, BURN_REGISTRATION_REGISTRY_BUNDLE_ADDON_CODE, &rgsczAddonCodes, &cAddonCodes);
+    if (SUCCEEDED(hr))
+    {
+        hr = DictCreateStringListFromArray(&sdAddonCodes, rgsczAddonCodes, cAddonCodes, DICT_FLAG_CASEINSENSITIVE);
+        ExitOnFailure(hr, "Failed to create string dictionary for %hs.", "addon codes");
+
+        // Addon relationship: when their addon codes match our detect codes.
+        hr = DictCompareStringListToArray(sdAddonCodes, const_cast<LPCWSTR*>(pRegistration->rgsczDetectCodes), pRegistration->cDetectCodes);
+        if (HRESULT_FROM_WIN32(ERROR_NO_MATCH) == hr)
+        {
+            hr = S_OK;
+        }
+        else
+        {
+            ExitOnFailure(hr, "Failed to do array search for addon code match.");
+
+            *pRelationType = BOOTSTRAPPER_RELATION_ADDON;
+            ExitFunction();
+        }
+
+        // Addon relationship: when their addon codes match our upgrade codes.
+        hr = DictCompareStringListToArray(sdAddonCodes, const_cast<LPCWSTR*>(pRegistration->rgsczUpgradeCodes), pRegistration->cUpgradeCodes);
+        if (HRESULT_FROM_WIN32(ERROR_NO_MATCH) == hr)
+        {
+            hr = S_OK;
+        }
+        else
+        {
+            ExitOnFailure(hr, "Failed to do array search for addon code match.");
+
+            *pRelationType = BOOTSTRAPPER_RELATION_ADDON;
+            ExitFunction();
+        }
+
+        ReleaseNullDict(sdAddonCodes);
+        ReleaseNullStrArray(rgsczAddonCodes, cAddonCodes);
+    }
+
+    // Compare patch codes.
+    hr = RegReadStringArray(hkBundleId, BURN_REGISTRATION_REGISTRY_BUNDLE_PATCH_CODE, &rgsczPatchCodes, &cPatchCodes);
+    if (SUCCEEDED(hr))
+    {
+        hr = DictCreateStringListFromArray(&sdPatchCodes, rgsczPatchCodes, cPatchCodes, DICT_FLAG_CASEINSENSITIVE);
+        ExitOnFailure(hr, "Failed to create string dictionary for %hs.", "patch codes");
+
+        // Patch relationship: when their patch codes match our detect codes.
+        hr = DictCompareStringListToArray(sdPatchCodes, const_cast<LPCWSTR*>(pRegistration->rgsczDetectCodes), pRegistration->cDetectCodes);
+        if (HRESULT_FROM_WIN32(ERROR_NO_MATCH) == hr)
+        {
+            hr = S_OK;
+        }
+        else
+        {
+            ExitOnFailure(hr, "Failed to do array search for patch code match.");
+
+            *pRelationType = BOOTSTRAPPER_RELATION_PATCH;
+            ExitFunction();
+        }
+
+        // Patch relationship: when their patch codes match our upgrade codes.
+        hr = DictCompareStringListToArray(sdPatchCodes, const_cast<LPCWSTR*>(pRegistration->rgsczUpgradeCodes), pRegistration->cUpgradeCodes);
+        if (HRESULT_FROM_WIN32(ERROR_NO_MATCH) == hr)
+        {
+            hr = S_OK;
+        }
+        else
+        {
+            ExitOnFailure(hr, "Failed to do array search for patch code match.");
+
+            *pRelationType = BOOTSTRAPPER_RELATION_PATCH;
+            ExitFunction();
+        }
+
+        ReleaseNullDict(sdPatchCodes);
+        ReleaseNullStrArray(rgsczPatchCodes, cPatchCodes);
+    }
+
+    // Compare detect codes.
+    hr = RegReadStringArray(hkBundleId, BURN_REGISTRATION_REGISTRY_BUNDLE_DETECT_CODE, &rgsczDetectCodes, &cDetectCodes);
+    if (SUCCEEDED(hr))
+    {
+        hr = DictCreateStringListFromArray(&sdDetectCodes, rgsczDetectCodes, cDetectCodes, DICT_FLAG_CASEINSENSITIVE);
+        ExitOnFailure(hr, "Failed to create string dictionary for %hs.", "detect codes");
+
+        // Detect relationship: when their detect codes match our detect codes.
+        hr = DictCompareStringListToArray(sdDetectCodes, const_cast<LPCWSTR*>(pRegistration->rgsczDetectCodes), pRegistration->cDetectCodes);
+        if (HRESULT_FROM_WIN32(ERROR_NO_MATCH) == hr)
+        {
+            hr = S_OK;
+        }
+        else
+        {
+            ExitOnFailure(hr, "Failed to do array search for detect code match.");
+
+            *pRelationType = BOOTSTRAPPER_RELATION_DETECT;
+            ExitFunction();
+        }
+
+        // Dependent relationship: when their detect codes match our addon codes.
+        hr = DictCompareStringListToArray(sdDetectCodes, const_cast<LPCWSTR*>(pRegistration->rgsczAddonCodes), pRegistration->cAddonCodes);
+        if (HRESULT_FROM_WIN32(ERROR_NO_MATCH) == hr)
+        {
+            hr = S_OK;
+        }
+        else
+        {
+            ExitOnFailure(hr, "Failed to do array search for addon code match.");
+
+            *pRelationType = BOOTSTRAPPER_RELATION_DEPENDENT;
+            ExitFunction();
+        }
+
+        // Dependent relationship: when their detect codes match our patch codes.
+        hr = DictCompareStringListToArray(sdDetectCodes, const_cast<LPCWSTR*>(pRegistration->rgsczPatchCodes), pRegistration->cPatchCodes);
+        if (HRESULT_FROM_WIN32(ERROR_NO_MATCH) == hr)
+        {
+            hr = S_OK;
+        }
+        else
+        {
+            ExitOnFailure(hr, "Failed to do array search for addon code match.");
+
+            *pRelationType = BOOTSTRAPPER_RELATION_DEPENDENT;
+            ExitFunction();
+        }
+
+        ReleaseNullDict(sdDetectCodes);
+        ReleaseNullStrArray(rgsczDetectCodes, cDetectCodes);
+    }
+
+LExit:
+    if (SUCCEEDED(hr) && BOOTSTRAPPER_RELATION_NONE == *pRelationType)
+    {
+        hr = E_NOTFOUND;
+    }
+
+    ReleaseDict(sdUpgradeCodes);
+    ReleaseStrArray(rgsczUpgradeCodes, cUpgradeCodes);
+    ReleaseDict(sdAddonCodes);
+    ReleaseStrArray(rgsczAddonCodes, cAddonCodes);
+    ReleaseDict(sdDetectCodes);
+    ReleaseStrArray(rgsczDetectCodes, cDetectCodes);
+    ReleaseDict(sdPatchCodes);
+    ReleaseStrArray(rgsczPatchCodes, cPatchCodes);
+
+    return hr;
+}
+
+static HRESULT LoadRelatedBundleFromKey(
+    __in_z LPCWSTR wzRelatedBundleId,
+    __in HKEY hkBundleId,
+    __in BOOL fPerMachine,
+    __in BOOTSTRAPPER_RELATION_TYPE relationType,
+    __inout BURN_RELATED_BUNDLE *pRelatedBundle
+    )
+{
+    HRESULT hr = S_OK;
+    DWORD64 qwEngineVersion = 0;
+    LPWSTR sczCachePath = NULL;
+    DWORD64 qwFileSize = 0;
+    BURN_DEPENDENCY_PROVIDER dependencyProvider = { };
+
+    hr = RegReadVersion(hkBundleId, BURN_REGISTRATION_REGISTRY_ENGINE_VERSION, &qwEngineVersion);
+    if (FAILED(hr))
+    {
+        qwEngineVersion = 0;
+        hr = S_OK;
+    }
+
+    hr = RegReadVersion(hkBundleId, BURN_REGISTRATION_REGISTRY_BUNDLE_VERSION, &pRelatedBundle->qwVersion);
+    ExitOnFailure(hr, "Failed to read version from registry for bundle: %ls", wzRelatedBundleId);
+
+    hr = RegReadString(hkBundleId, BURN_REGISTRATION_REGISTRY_BUNDLE_CACHE_PATH, &sczCachePath);
+    ExitOnFailure(hr, "Failed to read cache path from registry for bundle: %ls", wzRelatedBundleId);
+
+    hr = FileSize(sczCachePath, reinterpret_cast<LONGLONG *>(&qwFileSize));
+    ExitOnFailure(hr, "Failed to get size of pseudo bundle: %ls", sczCachePath);
+
+    hr = RegReadString(hkBundleId, BURN_REGISTRATION_REGISTRY_BUNDLE_PROVIDER_KEY, &dependencyProvider.sczKey);
+    if (E_FILENOTFOUND != hr)
+    {
+        ExitOnFailure(hr, "Failed to read provider key from registry for bundle: %ls", wzRelatedBundleId);
+
+        dependencyProvider.fImported = TRUE;
+
+        hr = FileVersionToStringEx(pRelatedBundle->qwVersion, &dependencyProvider.sczVersion);
+        ExitOnFailure(hr, "Failed to copy version for bundle: %ls", wzRelatedBundleId);
+
+        hr = RegReadString(hkBundleId, BURN_REGISTRATION_REGISTRY_BUNDLE_DISPLAY_NAME, &dependencyProvider.sczDisplayName);
+        if (E_FILENOTFOUND != hr)
+        {
+            ExitOnFailure(hr, "Failed to copy display name for bundle: %ls", wzRelatedBundleId);
+        }
+    }
+
+    hr = RegReadString(hkBundleId, BURN_REGISTRATION_REGISTRY_BUNDLE_TAG, &pRelatedBundle->sczTag);
+    if (E_FILENOTFOUND == hr)
+    {
+        hr = S_OK;
+    }
+    ExitOnFailure(hr, "Failed to read tag from registry for bundle: %ls", wzRelatedBundleId);
+
+    pRelatedBundle->relationType = relationType;
+
+    hr = PseudoBundleInitialize(qwEngineVersion, &pRelatedBundle->package, fPerMachine, wzRelatedBundleId, pRelatedBundle->relationType,
+                                BOOTSTRAPPER_PACKAGE_STATE_PRESENT, sczCachePath, sczCachePath, NULL, qwFileSize, FALSE,
+                                L"-quiet", L"-repair -quiet", L"-uninstall -quiet",
+                                (dependencyProvider.sczKey && *dependencyProvider.sczKey) ? &dependencyProvider : NULL,
+                                NULL, 0);
+    ExitOnFailure(hr, "Failed to initialize related bundle to represent bundle: %ls", wzRelatedBundleId);
+
+LExit:
+    DependencyUninitialize(&dependencyProvider);
+    ReleaseStr(sczCachePath);
+
+    return hr;
+}
diff --git a/src/engine/relatedbundle.h b/src/engine/relatedbundle.h
new file mode 100644
index 00000000..01691c25
--- /dev/null
+++ b/src/engine/relatedbundle.h
@@ -0,0 +1,20 @@
+#pragma once
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+HRESULT RelatedBundlesInitializeForScope(
+    __in BOOL fPerMachine,
+    __in BURN_REGISTRATION* pRegistration,
+    __in BURN_RELATED_BUNDLES* pRelatedBundles
+    );
+void RelatedBundlesUninitialize(
+    __in BURN_RELATED_BUNDLES* pRelatedBundles
+    );
+
+#if defined(__cplusplus)
+}
+#endif
diff --git a/src/engine/search.cpp b/src/engine/search.cpp
new file mode 100644
index 00000000..c50790fd
--- /dev/null
+++ b/src/engine/search.cpp
@@ -0,0 +1,1195 @@
+// 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.
+
+#include "precomp.h"
+
+
+// internal function declarations
+
+static HRESULT DirectorySearchExists(
+    __in BURN_SEARCH* pSearch,
+    __in BURN_VARIABLES* pVariables
+    );
+static HRESULT DirectorySearchPath(
+    __in BURN_SEARCH* pSearch,
+    __in BURN_VARIABLES* pVariables
+    );
+static HRESULT FileSearchExists(
+    __in BURN_SEARCH* pSearch,
+    __in BURN_VARIABLES* pVariables
+    );
+static HRESULT FileSearchVersion(
+    __in BURN_SEARCH* pSearch,
+    __in BURN_VARIABLES* pVariables
+    );
+static HRESULT FileSearchPath(
+    __in BURN_SEARCH* pSearch,
+    __in BURN_VARIABLES* pVariables
+    );
+static HRESULT RegistrySearchExists(
+    __in BURN_SEARCH* pSearch,
+    __in BURN_VARIABLES* pVariables
+    );
+static HRESULT RegistrySearchValue(
+    __in BURN_SEARCH* pSearch,
+    __in BURN_VARIABLES* pVariables
+    );
+static HRESULT MsiComponentSearch(
+    __in BURN_SEARCH* pSearch,
+    __in BURN_VARIABLES* pVariables
+    );
+static HRESULT MsiProductSearch(
+    __in BURN_SEARCH* pSearch,
+    __in BURN_VARIABLES* pVariables
+    );
+static HRESULT MsiFeatureSearch(
+    __in BURN_SEARCH* pSearch,
+    __in BURN_VARIABLES* pVariables
+    );
+
+
+// function definitions
+
+extern "C" HRESULT SearchesParseFromXml(
+    __in BURN_SEARCHES* pSearches,
+    __in IXMLDOMNode* pixnBundle
+    )
+{
+    HRESULT hr = S_OK;
+    IXMLDOMNodeList* pixnNodes = NULL;
+    IXMLDOMNode* pixnNode = NULL;
+    DWORD cNodes = 0;
+    BSTR bstrNodeName = NULL;
+    LPWSTR scz = NULL;
+
+    // select search nodes
+    hr = XmlSelectNodes(pixnBundle, L"DirectorySearch|FileSearch|RegistrySearch|MsiComponentSearch|MsiProductSearch|MsiFeatureSearch", &pixnNodes);
+    ExitOnFailure(hr, "Failed to select search nodes.");
+
+    // get search node count
+    hr = pixnNodes->get_length((long*)&cNodes);
+    ExitOnFailure(hr, "Failed to get search node count.");
+
+    if (!cNodes)
+    {
+        ExitFunction();
+    }
+
+    // allocate memory for searches
+    pSearches->rgSearches = (BURN_SEARCH*)MemAlloc(sizeof(BURN_SEARCH) * cNodes, TRUE);
+    ExitOnNull(pSearches->rgSearches, hr, E_OUTOFMEMORY, "Failed to allocate memory for search structs.");
+
+    pSearches->cSearches = cNodes;
+
+    // parse search elements
+    for (DWORD i = 0; i < cNodes; ++i)
+    {
+        BURN_SEARCH* pSearch = &pSearches->rgSearches[i];
+
+        hr = XmlNextElement(pixnNodes, &pixnNode, &bstrNodeName);
+        ExitOnFailure(hr, "Failed to get next node.");
+
+        // @Id
+        hr = XmlGetAttributeEx(pixnNode, L"Id", &pSearch->sczKey);
+        ExitOnFailure(hr, "Failed to get @Id.");
+
+        // @Variable
+        hr = XmlGetAttributeEx(pixnNode, L"Variable", &pSearch->sczVariable);
+        ExitOnFailure(hr, "Failed to get @Variable.");
+
+        // @Condition
+        hr = XmlGetAttributeEx(pixnNode, L"Condition", &pSearch->sczCondition);
+        if (E_NOTFOUND != hr)
+        {
+            ExitOnFailure(hr, "Failed to get @Condition.");
+        }
+
+        // read type specific attributes
+        if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, bstrNodeName, -1, L"DirectorySearch", -1))
+        {
+            pSearch->Type = BURN_SEARCH_TYPE_DIRECTORY;
+
+            // @Path
+            hr = XmlGetAttributeEx(pixnNode, L"Path", &pSearch->DirectorySearch.sczPath);
+            ExitOnFailure(hr, "Failed to get @Path.");
+
+            // @Type
+            hr = XmlGetAttributeEx(pixnNode, L"Type", &scz);
+            ExitOnFailure(hr, "Failed to get @Type.");
+
+            if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, scz, -1, L"exists", -1))
+            {
+                pSearch->DirectorySearch.Type = BURN_DIRECTORY_SEARCH_TYPE_EXISTS;
+            }
+            else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, scz, -1, L"path", -1))
+            {
+                pSearch->DirectorySearch.Type = BURN_DIRECTORY_SEARCH_TYPE_PATH;
+            }
+            else
+            {
+                hr = E_INVALIDARG;
+                ExitOnFailure(hr, "Invalid value for @Type: %ls", scz);
+            }
+        }
+        else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, bstrNodeName, -1, L"FileSearch", -1))
+        {
+            pSearch->Type = BURN_SEARCH_TYPE_FILE;
+
+            // @Path
+            hr = XmlGetAttributeEx(pixnNode, L"Path", &pSearch->FileSearch.sczPath);
+            ExitOnFailure(hr, "Failed to get @Path.");
+
+            // @Type
+            hr = XmlGetAttributeEx(pixnNode, L"Type", &scz);
+            ExitOnFailure(hr, "Failed to get @Type.");
+
+            if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, scz, -1, L"exists", -1))
+            {
+                pSearch->FileSearch.Type = BURN_FILE_SEARCH_TYPE_EXISTS;
+            }
+            else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, scz, -1, L"version", -1))
+            {
+                pSearch->FileSearch.Type = BURN_FILE_SEARCH_TYPE_VERSION;
+            }
+            else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, scz, -1, L"path", -1))
+            {
+                pSearch->FileSearch.Type = BURN_FILE_SEARCH_TYPE_PATH;
+            }
+            else
+            {
+                hr = E_INVALIDARG;
+                ExitOnFailure(hr, "Invalid value for @Type: %ls", scz);
+            }
+        }
+        else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, bstrNodeName, -1, L"RegistrySearch", -1))
+        {
+            pSearch->Type = BURN_SEARCH_TYPE_REGISTRY;
+
+            // @Root
+            hr = XmlGetAttributeEx(pixnNode, L"Root", &scz);
+            ExitOnFailure(hr, "Failed to get @Root.");
+
+            if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, scz, -1, L"HKCR", -1))
+            {
+                pSearch->RegistrySearch.hRoot = HKEY_CLASSES_ROOT;
+            }
+            else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, scz, -1, L"HKCU", -1))
+            {
+                pSearch->RegistrySearch.hRoot = HKEY_CURRENT_USER;
+            }
+            else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, scz, -1, L"HKLM", -1))
+            {
+                pSearch->RegistrySearch.hRoot = HKEY_LOCAL_MACHINE;
+            }
+            else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, scz, -1, L"HKU", -1))
+            {
+                pSearch->RegistrySearch.hRoot = HKEY_USERS;
+            }
+            else
+            {
+                hr = E_INVALIDARG;
+                ExitOnFailure(hr, "Invalid value for @Root: %ls", scz);
+            }
+
+            // @Key
+            hr = XmlGetAttributeEx(pixnNode, L"Key", &pSearch->RegistrySearch.sczKey);
+            ExitOnFailure(hr, "Failed to get Key attribute.");
+
+            // @Value
+            hr = XmlGetAttributeEx(pixnNode, L"Value", &pSearch->RegistrySearch.sczValue);
+            if (E_NOTFOUND != hr)
+            {
+                ExitOnFailure(hr, "Failed to get Value attribute.");
+            }
+
+            // @Type
+            hr = XmlGetAttributeEx(pixnNode, L"Type", &scz);
+            ExitOnFailure(hr, "Failed to get @Type.");
+
+            hr = XmlGetYesNoAttribute(pixnNode, L"Win64", &pSearch->RegistrySearch.fWin64);
+            if (E_NOTFOUND != hr)
+            {
+                ExitOnFailure(hr, "Failed to get Win64 attribute.");
+            }
+
+            if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, scz, -1, L"exists", -1))
+            {
+                pSearch->RegistrySearch.Type = BURN_REGISTRY_SEARCH_TYPE_EXISTS;
+            }
+            else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, scz, -1, L"value", -1))
+            {
+                pSearch->RegistrySearch.Type = BURN_REGISTRY_SEARCH_TYPE_VALUE;
+
+                // @ExpandEnvironment
+                hr = XmlGetYesNoAttribute(pixnNode, L"ExpandEnvironment", &pSearch->RegistrySearch.fExpandEnvironment);
+                if (E_NOTFOUND != hr)
+                {
+                    ExitOnFailure(hr, "Failed to get @ExpandEnvironment.");
+                }
+
+                // @VariableType
+                hr = XmlGetAttributeEx(pixnNode, L"VariableType", &scz);
+                ExitOnFailure(hr, "Failed to get @VariableType.");
+
+                if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, scz, -1, L"numeric", -1))
+                {
+                    pSearch->RegistrySearch.VariableType = BURN_VARIANT_TYPE_NUMERIC;
+                }
+                else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, scz, -1, L"string", -1))
+                {
+                    pSearch->RegistrySearch.VariableType = BURN_VARIANT_TYPE_STRING;
+                }
+                else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, scz, -1, L"version", -1))
+                {
+                    pSearch->RegistrySearch.VariableType = BURN_VARIANT_TYPE_VERSION;
+                }
+                else
+                {
+                    hr = E_INVALIDARG;
+                    ExitOnFailure(hr, "Invalid value for @VariableType: %ls", scz);
+                }
+            }
+            else
+            {
+                hr = E_INVALIDARG;
+                ExitOnFailure(hr, "Invalid value for @Type: %ls", scz);
+            }
+        }
+        else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, bstrNodeName, -1, L"MsiComponentSearch", -1))
+        {
+            pSearch->Type = BURN_SEARCH_TYPE_MSI_COMPONENT;
+
+            // @ProductCode
+            hr = XmlGetAttributeEx(pixnNode, L"ProductCode", &pSearch->MsiComponentSearch.sczProductCode);
+            if (E_NOTFOUND != hr)
+            {
+                ExitOnFailure(hr, "Failed to get @ProductCode.");
+            }
+
+            // @ComponentId
+            hr = XmlGetAttributeEx(pixnNode, L"ComponentId", &pSearch->MsiComponentSearch.sczComponentId);
+            ExitOnFailure(hr, "Failed to get @ComponentId.");
+
+            // @Type
+            hr = XmlGetAttributeEx(pixnNode, L"Type", &scz);
+            ExitOnFailure(hr, "Failed to get @Type.");
+
+            if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, scz, -1, L"keyPath", -1))
+            {
+                pSearch->MsiComponentSearch.Type = BURN_MSI_COMPONENT_SEARCH_TYPE_KEYPATH;
+            }
+            else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, scz, -1, L"state", -1))
+            {
+                pSearch->MsiComponentSearch.Type = BURN_MSI_COMPONENT_SEARCH_TYPE_STATE;
+            }
+            else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, scz, -1, L"directory", -1))
+            {
+                pSearch->MsiComponentSearch.Type = BURN_MSI_COMPONENT_SEARCH_TYPE_DIRECTORY;
+            }
+            else
+            {
+                hr = E_INVALIDARG;
+                ExitOnFailure(hr, "Invalid value for @Type: %ls", scz);
+            }
+        }
+        else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, bstrNodeName, -1, L"MsiProductSearch", -1))
+        {
+            pSearch->Type = BURN_SEARCH_TYPE_MSI_PRODUCT;
+            pSearch->MsiProductSearch.GuidType = BURN_MSI_PRODUCT_SEARCH_GUID_TYPE_NONE;
+
+            // @ProductCode (if we don't find a product code then look for an upgrade code)
+            hr = XmlGetAttributeEx(pixnNode, L"ProductCode", &pSearch->MsiProductSearch.sczGuid);
+            if (E_NOTFOUND != hr)
+            {
+                ExitOnFailure(hr, "Failed to get @ProductCode.");
+                pSearch->MsiProductSearch.GuidType = BURN_MSI_PRODUCT_SEARCH_GUID_TYPE_PRODUCTCODE;
+            }
+            else
+            {
+                // @UpgradeCode
+                hr = XmlGetAttributeEx(pixnNode, L"UpgradeCode", &pSearch->MsiProductSearch.sczGuid);
+                if (E_NOTFOUND != hr)
+                {
+                    ExitOnFailure(hr, "Failed to get @UpgradeCode.");
+                    pSearch->MsiProductSearch.GuidType = BURN_MSI_PRODUCT_SEARCH_GUID_TYPE_UPGRADECODE;
+                }
+            }
+
+            // make sure we found either a product or upgrade code
+            if (BURN_MSI_PRODUCT_SEARCH_GUID_TYPE_NONE == pSearch->MsiProductSearch.GuidType)
+            {
+                hr = E_NOTFOUND;
+                ExitOnFailure(hr, "Failed to get @ProductCode or @UpgradeCode.");
+            }
+
+            // @Type
+            hr = XmlGetAttributeEx(pixnNode, L"Type", &scz);
+            ExitOnFailure(hr, "Failed to get @Type.");
+
+            if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, scz, -1, L"version", -1))
+            {
+                pSearch->MsiProductSearch.Type = BURN_MSI_PRODUCT_SEARCH_TYPE_VERSION;
+            }
+            else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, scz, -1, L"language", -1))
+            {
+                pSearch->MsiProductSearch.Type = BURN_MSI_PRODUCT_SEARCH_TYPE_LANGUAGE;
+            }
+            else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, scz, -1, L"state", -1))
+            {
+                pSearch->MsiProductSearch.Type = BURN_MSI_PRODUCT_SEARCH_TYPE_STATE;
+            }
+            else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, scz, -1, L"assignment", -1))
+            {
+                pSearch->MsiProductSearch.Type = BURN_MSI_PRODUCT_SEARCH_TYPE_ASSIGNMENT;
+            }
+            else
+            {
+                hr = E_INVALIDARG;
+                ExitOnFailure(hr, "Invalid value for @Type: %ls", scz);
+            }
+        }
+        else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, bstrNodeName, -1, L"MsiFeatureSearch", -1))
+        {
+            pSearch->Type = BURN_SEARCH_TYPE_MSI_FEATURE;
+
+            // @ProductCode
+            hr = XmlGetAttributeEx(pixnNode, L"ProductCode", &pSearch->MsiFeatureSearch.sczProductCode);
+            ExitOnFailure(hr, "Failed to get @ProductCode.");
+
+            // @FeatureId
+            hr = XmlGetAttributeEx(pixnNode, L"FeatureId", &pSearch->MsiFeatureSearch.sczFeatureId);
+            ExitOnFailure(hr, "Failed to get @FeatureId.");
+
+            // @Type
+            hr = XmlGetAttributeEx(pixnNode, L"Type", &scz);
+            ExitOnFailure(hr, "Failed to get @Type.");
+
+            if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, scz, -1, L"state", -1))
+            {
+                pSearch->MsiFeatureSearch.Type = BURN_MSI_FEATURE_SEARCH_TYPE_STATE;
+            }
+            else
+            {
+                hr = E_INVALIDARG;
+                ExitOnFailure(hr, "Invalid value for @Type: %ls", scz);
+            }
+        }
+        else
+        {
+            hr = E_UNEXPECTED;
+            ExitOnFailure(hr, "Unexpected element name: %ls", bstrNodeName);
+        }
+
+        // prepare next iteration
+        ReleaseNullObject(pixnNode);
+        ReleaseNullBSTR(bstrNodeName);
+    }
+
+    hr = S_OK;
+
+LExit:
+    ReleaseObject(pixnNodes);
+    ReleaseObject(pixnNode);
+    ReleaseBSTR(bstrNodeName);
+    ReleaseStr(scz);
+    return hr;
+}
+
+extern "C" HRESULT SearchesExecute(
+    __in BURN_SEARCHES* pSearches,
+    __in BURN_VARIABLES* pVariables
+    )
+{
+    HRESULT hr = S_OK;
+    BOOL f = FALSE;
+
+    for (DWORD i = 0; i < pSearches->cSearches; ++i)
+    {
+        BURN_SEARCH* pSearch = &pSearches->rgSearches[i];
+
+        // evaluate condition
+        if (pSearch->sczCondition && *pSearch->sczCondition)
+        {
+            hr = ConditionEvaluate(pVariables, pSearch->sczCondition, &f);
+            if (E_INVALIDDATA == hr)
+            {
+                TraceError(hr, "Failed to parse search condition. Id = '%ls', Condition = '%ls'", pSearch->sczKey, pSearch->sczCondition);
+                hr = S_OK;
+                continue;
+            }
+            ExitOnFailure(hr, "Failed to evaluate search condition. Id = '%ls', Condition = '%ls'", pSearch->sczKey, pSearch->sczCondition);
+
+            if (!f)
+            {
+                continue; // condition evaluated to false, skip
+            }
+        }
+
+        switch (pSearch->Type)
+        {
+        case BURN_SEARCH_TYPE_DIRECTORY:
+            switch (pSearch->DirectorySearch.Type)
+            {
+            case BURN_DIRECTORY_SEARCH_TYPE_EXISTS:
+                hr = DirectorySearchExists(pSearch, pVariables);
+                break;
+            case BURN_DIRECTORY_SEARCH_TYPE_PATH:
+                hr = DirectorySearchPath(pSearch, pVariables);
+                break;
+            default:
+                hr = E_UNEXPECTED;
+            }
+            break;
+        case BURN_SEARCH_TYPE_FILE:
+            switch (pSearch->FileSearch.Type)
+            {
+            case BURN_FILE_SEARCH_TYPE_EXISTS:
+                hr = FileSearchExists(pSearch, pVariables);
+                break;
+            case BURN_FILE_SEARCH_TYPE_VERSION:
+                hr = FileSearchVersion(pSearch, pVariables);
+                break;
+            case BURN_FILE_SEARCH_TYPE_PATH:
+                hr = FileSearchPath(pSearch, pVariables);
+                break;
+            default:
+                hr = E_UNEXPECTED;
+            }
+            break;
+        case BURN_SEARCH_TYPE_REGISTRY:
+            switch (pSearch->RegistrySearch.Type)
+            {
+            case BURN_REGISTRY_SEARCH_TYPE_EXISTS:
+                hr = RegistrySearchExists(pSearch, pVariables);
+                break;
+            case BURN_REGISTRY_SEARCH_TYPE_VALUE:
+                hr = RegistrySearchValue(pSearch, pVariables);
+                break;
+            default:
+                hr = E_UNEXPECTED;
+            }
+            break;
+        case BURN_SEARCH_TYPE_MSI_COMPONENT:
+            hr = MsiComponentSearch(pSearch, pVariables);
+            break;
+        case BURN_SEARCH_TYPE_MSI_PRODUCT:
+            hr = MsiProductSearch(pSearch, pVariables);
+            break;
+        case BURN_SEARCH_TYPE_MSI_FEATURE:
+            hr = MsiFeatureSearch(pSearch, pVariables);
+            break;
+        default:
+            hr = E_UNEXPECTED;
+        }
+
+        if (FAILED(hr))
+        {
+            TraceError(hr, "Search failed. Id = '%ls'", pSearch->sczKey);
+            continue;
+        }
+    }
+
+    hr = S_OK;
+
+LExit:
+    return hr;
+}
+
+extern "C" void SearchesUninitialize(
+    __in BURN_SEARCHES* pSearches
+    )
+{
+    if (pSearches->rgSearches)
+    {
+        for (DWORD i = 0; i < pSearches->cSearches; ++i)
+        {
+            BURN_SEARCH* pSearch = &pSearches->rgSearches[i];
+
+            ReleaseStr(pSearch->sczKey);
+            ReleaseStr(pSearch->sczVariable);
+            ReleaseStr(pSearch->sczCondition);
+
+            switch (pSearch->Type)
+            {
+            case BURN_SEARCH_TYPE_DIRECTORY:
+                ReleaseStr(pSearch->DirectorySearch.sczPath);
+                break;
+            case BURN_SEARCH_TYPE_FILE:
+                ReleaseStr(pSearch->FileSearch.sczPath);
+                break;
+            case BURN_SEARCH_TYPE_REGISTRY:
+                ReleaseStr(pSearch->RegistrySearch.sczKey);
+                ReleaseStr(pSearch->RegistrySearch.sczValue);
+                break;
+            case BURN_SEARCH_TYPE_MSI_COMPONENT:
+                ReleaseStr(pSearch->MsiComponentSearch.sczProductCode);
+                ReleaseStr(pSearch->MsiComponentSearch.sczComponentId);
+                break;
+            case BURN_SEARCH_TYPE_MSI_PRODUCT:
+                ReleaseStr(pSearch->MsiProductSearch.sczGuid);
+                break;
+            case BURN_SEARCH_TYPE_MSI_FEATURE:
+                ReleaseStr(pSearch->MsiFeatureSearch.sczProductCode);
+                ReleaseStr(pSearch->MsiFeatureSearch.sczFeatureId);
+                break;
+            }
+        }
+        MemFree(pSearches->rgSearches);
+    }
+}
+
+
+// internal function definitions
+
+static HRESULT DirectorySearchExists(
+    __in BURN_SEARCH* pSearch,
+    __in BURN_VARIABLES* pVariables
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR sczPath = NULL;
+    BOOL fExists = FALSE;
+
+    // format path
+    hr = VariableFormatString(pVariables, pSearch->DirectorySearch.sczPath, &sczPath, NULL);
+    ExitOnFailure(hr, "Failed to format variable string.");
+
+    DWORD dwAttributes = ::GetFileAttributesW(sczPath);
+    if (INVALID_FILE_ATTRIBUTES == dwAttributes)
+    {
+        hr = HRESULT_FROM_WIN32(::GetLastError());
+        if (E_FILENOTFOUND == hr || E_PATHNOTFOUND == hr)
+        {
+            hr = S_OK; // didn't find file, fExists still is false.
+        }
+    }
+    else if (dwAttributes & FILE_ATTRIBUTE_DIRECTORY)
+    {
+        fExists = TRUE;
+    }
+
+    // else must have found a file.
+    // What if there is a hidden variable in sczPath?
+    ExitOnFailure(hr, "Failed while searching directory search: %ls, for path: %ls", pSearch->sczKey, sczPath);
+
+    // set variable
+    hr = VariableSetNumeric(pVariables, pSearch->sczVariable, fExists, FALSE);
+    ExitOnFailure(hr, "Failed to set variable.");
+
+LExit:
+    StrSecureZeroFreeString(sczPath);
+
+    return hr;
+}
+
+static HRESULT DirectorySearchPath(
+    __in BURN_SEARCH* pSearch,
+    __in BURN_VARIABLES* pVariables
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR sczPath = NULL;
+
+    // format path
+    hr = VariableFormatString(pVariables, pSearch->DirectorySearch.sczPath, &sczPath, NULL);
+    ExitOnFailure(hr, "Failed to format variable string.");
+
+    DWORD dwAttributes = ::GetFileAttributesW(sczPath);
+    if (INVALID_FILE_ATTRIBUTES == dwAttributes)
+    {
+        hr = HRESULT_FROM_WIN32(::GetLastError());
+    }
+    else if (dwAttributes & FILE_ATTRIBUTE_DIRECTORY)
+    {
+        hr = VariableSetLiteralString(pVariables, pSearch->sczVariable, sczPath, FALSE);
+        ExitOnFailure(hr, "Failed to set directory search path variable.");
+    }
+    else // must have found a file.
+    {
+        hr = E_PATHNOTFOUND;
+    }
+
+    // What if there is a hidden variable in sczPath?
+    if (E_FILENOTFOUND == hr || E_PATHNOTFOUND == hr)
+    {
+        LogStringLine(REPORT_STANDARD, "Directory search: %ls, did not find path: %ls, reason: 0x%x", pSearch->sczKey, sczPath, hr);
+        ExitFunction1(hr = S_OK);
+    }
+    ExitOnFailure(hr, "Failed while searching directory search: %ls, for path: %ls", pSearch->sczKey, sczPath);
+
+LExit:
+    StrSecureZeroFreeString(sczPath);
+
+    return hr;
+}
+
+static HRESULT FileSearchExists(
+    __in BURN_SEARCH* pSearch,
+    __in BURN_VARIABLES* pVariables
+    )
+{
+    HRESULT hr = S_OK;
+    DWORD er = ERROR_SUCCESS;
+    LPWSTR sczPath = NULL;
+    BOOL fExists = FALSE;
+
+    // format path
+    hr = VariableFormatString(pVariables, pSearch->FileSearch.sczPath, &sczPath, NULL);
+    ExitOnFailure(hr, "Failed to format variable string.");
+
+    // find file
+    DWORD dwAttributes = ::GetFileAttributesW(sczPath);
+    if (INVALID_FILE_ATTRIBUTES == dwAttributes)
+    {
+        er = ::GetLastError();
+        if (ERROR_FILE_NOT_FOUND == er || ERROR_PATH_NOT_FOUND == er)
+        {
+            // What if there is a hidden variable in sczPath?
+            LogStringLine(REPORT_STANDARD, "File search: %ls, did not find path: %ls", pSearch->sczKey, sczPath);
+        }
+        else
+        {
+            ExitOnWin32Error(er, hr, "Failed get to file attributes. '%ls'", pSearch->DirectorySearch.sczPath);
+        }
+    }
+    else if (FILE_ATTRIBUTE_DIRECTORY != (dwAttributes & FILE_ATTRIBUTE_DIRECTORY))
+    {
+        fExists = TRUE;
+    }
+
+    // set variable
+    hr = VariableSetNumeric(pVariables, pSearch->sczVariable, fExists, FALSE);
+    ExitOnFailure(hr, "Failed to set variable.");
+
+LExit:
+    StrSecureZeroFreeString(sczPath);
+    return hr;
+}
+
+static HRESULT FileSearchVersion(
+    __in BURN_SEARCH* pSearch,
+    __in BURN_VARIABLES* pVariables
+    )
+{
+    HRESULT hr = S_OK;
+    ULARGE_INTEGER uliVersion = { };
+    LPWSTR sczPath = NULL;
+
+    // format path
+    hr = VariableFormatString(pVariables, pSearch->FileSearch.sczPath, &sczPath, NULL);
+    ExitOnFailure(hr, "Failed to format path string.");
+
+    // get file version
+    hr = FileVersion(sczPath, &uliVersion.HighPart, &uliVersion.LowPart);
+    if (E_FILENOTFOUND == hr || E_PATHNOTFOUND == hr)
+    {
+        // What if there is a hidden variable in sczPath?
+        LogStringLine(REPORT_STANDARD, "File search: %ls, did not find path: %ls", pSearch->sczKey, sczPath);
+        ExitFunction1(hr = S_OK);
+    }
+    ExitOnFailure(hr, "Failed get file version.");
+
+    // set variable
+    hr = VariableSetVersion(pVariables, pSearch->sczVariable, uliVersion.QuadPart, FALSE);
+    ExitOnFailure(hr, "Failed to set variable.");
+
+LExit:
+    StrSecureZeroFreeString(sczPath);
+    return hr;
+}
+
+static HRESULT FileSearchPath(
+    __in BURN_SEARCH* pSearch,
+    __in BURN_VARIABLES* pVariables
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR sczPath = NULL;
+
+    // format path
+    hr = VariableFormatString(pVariables, pSearch->FileSearch.sczPath, &sczPath, NULL);
+    ExitOnFailure(hr, "Failed to format variable string.");
+
+    DWORD dwAttributes = ::GetFileAttributesW(sczPath);
+    if (INVALID_FILE_ATTRIBUTES == dwAttributes)
+    {
+        hr = HRESULT_FROM_WIN32(::GetLastError());
+    }
+    else if (dwAttributes & FILE_ATTRIBUTE_DIRECTORY) // found a directory.
+    {
+        hr = E_FILENOTFOUND;
+    }
+    else // found our file.
+    {
+        hr = VariableSetLiteralString(pVariables, pSearch->sczVariable, sczPath, FALSE);
+        ExitOnFailure(hr, "Failed to set variable to file search path.");
+    }
+
+    // What if there is a hidden variable in sczPath?
+    if (E_FILENOTFOUND == hr || E_PATHNOTFOUND == hr)
+    {
+        LogStringLine(REPORT_STANDARD, "File search: %ls, did not find path: %ls", pSearch->sczKey, sczPath);
+        ExitFunction1(hr = S_OK);
+    }
+    ExitOnFailure(hr, "Failed while searching file search: %ls, for path: %ls", pSearch->sczKey, sczPath);
+
+LExit:
+    StrSecureZeroFreeString(sczPath);
+
+    return hr;
+}
+
+static HRESULT RegistrySearchExists(
+    __in BURN_SEARCH* pSearch,
+    __in BURN_VARIABLES* pVariables
+    )
+{
+    HRESULT hr = S_OK;
+    DWORD er = ERROR_SUCCESS;
+    LPWSTR sczKey = NULL;
+    LPWSTR sczValue = NULL;
+    HKEY hKey = NULL;
+    DWORD dwType = 0;
+    BOOL fExists = FALSE;
+    REGSAM samDesired = KEY_QUERY_VALUE;
+
+    if (pSearch->RegistrySearch.fWin64)
+    {
+        samDesired = samDesired | KEY_WOW64_64KEY;
+    }
+
+    // format key string
+    hr = VariableFormatString(pVariables, pSearch->RegistrySearch.sczKey, &sczKey, NULL);
+    ExitOnFailure(hr, "Failed to format key string.");
+
+    // open key
+    hr = RegOpen(pSearch->RegistrySearch.hRoot, sczKey, samDesired, &hKey);
+    if (SUCCEEDED(hr))
+    {
+        fExists = TRUE;
+    }
+    else if (E_FILENOTFOUND == hr)
+    {
+        // What if there is a hidden variable in sczKey?
+        LogStringLine(REPORT_STANDARD, "Registry key not found. Key = '%ls'", sczKey);
+        fExists = FALSE;
+        hr = S_OK;
+    }
+    else
+    {
+        // What if there is a hidden variable in sczKey?
+        ExitOnFailure(hr, "Failed to open registry key. Key = '%ls'", sczKey);
+    }
+
+    if (fExists && pSearch->RegistrySearch.sczValue)
+    {
+        // format value string
+        hr = VariableFormatString(pVariables, pSearch->RegistrySearch.sczValue, &sczValue, NULL);
+        ExitOnFailure(hr, "Failed to format value string.");
+
+        // query value
+        er = ::RegQueryValueExW(hKey, sczValue, NULL, &dwType, NULL, NULL);
+        switch (er)
+        {
+        case ERROR_SUCCESS:
+            fExists = TRUE;
+            break;
+        case ERROR_FILE_NOT_FOUND:
+            // What if there is a hidden variable in sczKey or sczValue?
+            LogStringLine(REPORT_STANDARD, "Registry value not found. Key = '%ls', Value = '%ls'", sczKey, sczValue);
+            fExists = FALSE;
+            break;
+        default:
+            ExitOnWin32Error(er, hr, "Failed to query registry key value.");
+        }
+    }
+
+    // set variable
+    hr = VariableSetNumeric(pVariables, pSearch->sczVariable, fExists, FALSE);
+    ExitOnFailure(hr, "Failed to set variable.");
+
+LExit:
+    if (FAILED(hr))
+    {
+        // What if there is a hidden variable in sczKey?
+        LogStringLine(REPORT_STANDARD, "RegistrySearchExists failed: ID '%ls', HRESULT 0x%x", sczKey, hr);
+    }
+
+    StrSecureZeroFreeString(sczKey);
+    StrSecureZeroFreeString(sczValue);
+    ReleaseRegKey(hKey);
+
+    return hr;
+}
+
+static HRESULT RegistrySearchValue(
+    __in BURN_SEARCH* pSearch,
+    __in BURN_VARIABLES* pVariables
+    )
+{
+    HRESULT hr = S_OK;
+    DWORD er = ERROR_SUCCESS;
+    LPWSTR sczKey = NULL;
+    LPWSTR sczValue = NULL;
+    HKEY hKey = NULL;
+    DWORD dwType = 0;
+    DWORD cbData = 0;
+    LPBYTE pData = NULL;
+    DWORD cch = 0;
+    BURN_VARIANT value = { };
+    REGSAM samDesired = KEY_QUERY_VALUE;
+
+    if (pSearch->RegistrySearch.fWin64)
+    {
+        samDesired = samDesired | KEY_WOW64_64KEY;
+    }
+
+    // format key string
+    hr = VariableFormatString(pVariables, pSearch->RegistrySearch.sczKey, &sczKey, NULL);
+    ExitOnFailure(hr, "Failed to format key string.");
+
+    // format value string
+    if (pSearch->RegistrySearch.sczValue)
+    {
+        hr = VariableFormatString(pVariables, pSearch->RegistrySearch.sczValue, &sczValue, NULL);
+        ExitOnFailure(hr, "Failed to format value string.");
+    }
+
+    // open key
+    hr = RegOpen(pSearch->RegistrySearch.hRoot, sczKey, samDesired, &hKey);
+    if (E_FILENOTFOUND == hr)
+    {
+        // What if there is a hidden variable in sczKey?
+        LogStringLine(REPORT_STANDARD, "Registry key not found. Key = '%ls'", sczKey);
+        hr = VariableSetLiteralVariant(pVariables, pSearch->sczVariable, &value);
+        ExitOnFailure(hr, "Failed to clear variable.");
+        ExitFunction1(hr = S_OK);
+    }
+    ExitOnFailure(hr, "Failed to open registry key.");
+
+    // get value
+    er = ::RegQueryValueExW(hKey, sczValue, NULL, &dwType, NULL, &cbData);
+    if (ERROR_FILE_NOT_FOUND == er)
+    {
+        // What if there is a hidden variable in sczKey or sczValue?
+        LogStringLine(REPORT_STANDARD, "Registry value not found. Key = '%ls', Value = '%ls'", sczKey, sczValue);
+        hr = VariableSetLiteralVariant(pVariables, pSearch->sczVariable, &value);
+        ExitOnFailure(hr, "Failed to clear variable.");
+        ExitFunction1(hr = S_OK);
+    }
+    ExitOnWin32Error(er, hr, "Failed to query registry key value size.");
+
+    pData = (LPBYTE)MemAlloc(cbData + sizeof(WCHAR), TRUE); // + sizeof(WCHAR) here to ensure that we always have a null terminator for REG_SZ
+    ExitOnNull(pData, hr, E_OUTOFMEMORY, "Failed to allocate memory registry value.");
+
+    er = ::RegQueryValueExW(hKey, sczValue, NULL, &dwType, pData, &cbData);
+    ExitOnWin32Error(er, hr, "Failed to query registry key value.");
+
+    switch (dwType)
+    {
+    case REG_DWORD:
+        if (sizeof(LONG) != cbData)
+        {
+            ExitFunction1(hr = E_UNEXPECTED);
+        }
+        hr = BVariantSetNumeric(&value, *((LONG*)pData));
+        break;
+    case REG_QWORD:
+        if (sizeof(LONGLONG) != cbData)
+        {
+            ExitFunction1(hr = E_UNEXPECTED);
+        }
+        hr = BVariantSetNumeric(&value, *((LONGLONG*)pData));
+        break;
+    case REG_EXPAND_SZ:
+        if (pSearch->RegistrySearch.fExpandEnvironment)
+        {
+            hr = StrAlloc(&value.sczValue, cbData);
+            ExitOnFailure(hr, "Failed to allocate string buffer.");
+            value.Type = BURN_VARIANT_TYPE_STRING;
+
+            cch = ::ExpandEnvironmentStringsW((LPCWSTR)pData, value.sczValue, cbData);
+            if (cch > cbData)
+            {
+                hr = StrAlloc(&value.sczValue, cch);
+                ExitOnFailure(hr, "Failed to allocate string buffer.");
+
+                if (cch != ::ExpandEnvironmentStringsW((LPCWSTR)pData, value.sczValue, cch))
+                {
+                    ExitWithLastError(hr, "Failed to get expand environment string.");
+                }
+            }
+            break;
+        }
+        __fallthrough;
+    case REG_SZ:
+        hr = BVariantSetString(&value, (LPCWSTR)pData, 0);
+        break;
+    default:
+        ExitOnFailure(hr = E_NOTIMPL, "Unsupported registry key value type. Type = '%u'", dwType);
+    }
+    ExitOnFailure(hr, "Failed to read registry value.");
+
+    // change value to requested type
+    hr = BVariantChangeType(&value, pSearch->RegistrySearch.VariableType);
+    ExitOnFailure(hr, "Failed to change value type.");
+
+    // Set variable as a literal.
+    hr = VariableSetLiteralVariant(pVariables, pSearch->sczVariable, &value);
+    ExitOnFailure(hr, "Failed to set variable.");
+
+LExit:
+    if (FAILED(hr))
+    {
+        // What if there is a hidden variable in sczKey?
+        LogStringLine(REPORT_STANDARD, "RegistrySearchValue failed: ID '%ls', HRESULT 0x%x", sczKey, hr);
+    }
+
+    StrSecureZeroFreeString(sczKey);
+    StrSecureZeroFreeString(sczValue);
+    ReleaseRegKey(hKey);
+    ReleaseMem(pData);
+    BVariantUninitialize(&value);
+
+    return hr;
+}
+
+static HRESULT MsiComponentSearch(
+    __in BURN_SEARCH* pSearch,
+    __in BURN_VARIABLES* pVariables
+    )
+{
+    HRESULT hr = S_OK;
+    INSTALLSTATE is = INSTALLSTATE_BROKEN;
+    LPWSTR sczComponentId = NULL;
+    LPWSTR sczProductCode = NULL;
+    LPWSTR sczPath = NULL;
+
+    // format component id string
+    hr = VariableFormatString(pVariables, pSearch->MsiComponentSearch.sczComponentId, &sczComponentId, NULL);
+    ExitOnFailure(hr, "Failed to format component id string.");
+
+    if (pSearch->MsiComponentSearch.sczProductCode)
+    {
+        // format product code string
+        hr = VariableFormatString(pVariables, pSearch->MsiComponentSearch.sczProductCode, &sczProductCode, NULL);
+        ExitOnFailure(hr, "Failed to format product code string.");
+    }
+
+    if (sczProductCode)
+    {
+        hr = WiuGetComponentPath(sczProductCode, sczComponentId, &is, &sczPath);
+    }
+    else
+    {
+        hr = WiuLocateComponent(sczComponentId, &is, &sczPath);
+    }
+
+    if (INSTALLSTATE_SOURCEABSENT == is)
+    {
+        is = INSTALLSTATE_SOURCE;
+    }
+    else if (INSTALLSTATE_UNKNOWN == is || INSTALLSTATE_NOTUSED == is)
+    {
+        is = INSTALLSTATE_ABSENT;
+    }
+    else if (INSTALLSTATE_ABSENT != is && INSTALLSTATE_LOCAL != is && INSTALLSTATE_SOURCE != is)
+    {
+        hr = E_INVALIDARG;
+        ExitOnFailure(hr, "Failed to get component path: %d", is);
+    }
+
+    // set variable
+    switch (pSearch->MsiComponentSearch.Type)
+    {
+    case BURN_MSI_COMPONENT_SEARCH_TYPE_KEYPATH:
+        if (INSTALLSTATE_ABSENT == is || INSTALLSTATE_LOCAL == is || INSTALLSTATE_SOURCE == is)
+        {
+            hr = VariableSetLiteralString(pVariables, pSearch->sczVariable, sczPath, FALSE);
+        }
+        break;
+    case BURN_MSI_COMPONENT_SEARCH_TYPE_STATE:
+        hr = VariableSetNumeric(pVariables, pSearch->sczVariable, is, FALSE);
+        break;
+    case BURN_MSI_COMPONENT_SEARCH_TYPE_DIRECTORY:
+        if (INSTALLSTATE_ABSENT == is || INSTALLSTATE_LOCAL == is || INSTALLSTATE_SOURCE == is)
+        {
+            // remove file part from path, if any
+            LPWSTR wz = wcsrchr(sczPath, L'\\');
+            if (wz)
+            {
+                wz[1] = L'\0';
+            }
+
+            hr = VariableSetLiteralString(pVariables, pSearch->sczVariable, sczPath, FALSE);
+        }
+        break;
+    }
+    ExitOnFailure(hr, "Failed to set variable.");
+
+LExit:
+    if (FAILED(hr))
+    {
+        LogStringLine(REPORT_STANDARD, "MsiComponentSearch failed: ID '%ls', HRESULT 0x%x", pSearch->sczKey, hr);
+    }
+
+    StrSecureZeroFreeString(sczComponentId);
+    StrSecureZeroFreeString(sczProductCode);
+    ReleaseStr(sczPath);
+    return hr;
+}
+
+static HRESULT MsiProductSearch(
+    __in BURN_SEARCH* pSearch,
+    __in BURN_VARIABLES* pVariables
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR sczGuid = NULL;
+    LPCWSTR wzProperty = NULL;
+    LPWSTR *rgsczRelatedProductCodes = NULL;
+    DWORD dwRelatedProducts = 0;
+    BURN_VARIANT_TYPE type = BURN_VARIANT_TYPE_NONE;
+    BURN_VARIANT value = { };
+    // We're not going to encrypt this value, so can access the value directly.
+
+    switch (pSearch->MsiProductSearch.Type)
+    {
+    case BURN_MSI_PRODUCT_SEARCH_TYPE_VERSION:
+        wzProperty = INSTALLPROPERTY_VERSIONSTRING;
+        break;
+    case BURN_MSI_PRODUCT_SEARCH_TYPE_LANGUAGE:
+        wzProperty = INSTALLPROPERTY_LANGUAGE;
+        break;
+    case BURN_MSI_PRODUCT_SEARCH_TYPE_STATE:
+        wzProperty = INSTALLPROPERTY_PRODUCTSTATE;
+        break;
+    case BURN_MSI_PRODUCT_SEARCH_TYPE_ASSIGNMENT:
+        wzProperty = INSTALLPROPERTY_ASSIGNMENTTYPE;
+        break;
+    default:
+        ExitOnFailure(hr = E_NOTIMPL, "Unsupported product search type: %u", pSearch->MsiProductSearch.Type);
+    }
+
+    // format guid string
+    hr = VariableFormatString(pVariables, pSearch->MsiProductSearch.sczGuid, &sczGuid, NULL);
+    ExitOnFailure(hr, "Failed to format GUID string.");
+
+    // get product info
+    value.Type = BURN_VARIANT_TYPE_STRING;
+
+    // if this is an upgrade code then get the product code of the highest versioned related product
+    if (BURN_MSI_PRODUCT_SEARCH_GUID_TYPE_UPGRADECODE == pSearch->MsiProductSearch.GuidType)
+    {
+        // WiuEnumRelatedProductCodes will log sczGuid on errors, what if there's a hidden variable in there?
+        hr = WiuEnumRelatedProductCodes(sczGuid, &rgsczRelatedProductCodes, &dwRelatedProducts, TRUE);
+        ExitOnFailure(hr, "Failed to enumerate related products for upgrade code.");
+
+        // if we actually found a related product then use its upgrade code for the rest of the search
+        if (1 == dwRelatedProducts)
+        {
+            hr = StrAllocStringSecure(&sczGuid, rgsczRelatedProductCodes[0], 0);
+            ExitOnFailure(hr, "Failed to copy upgrade code.");
+        }
+        else
+        {
+            // set this here so we have a way of knowing that we don't need to bother
+            // querying for the product information below
+            hr = HRESULT_FROM_WIN32(ERROR_UNKNOWN_PRODUCT);
+        }
+    }
+
+    if (HRESULT_FROM_WIN32(ERROR_UNKNOWN_PRODUCT) != hr)
+    {
+        hr = WiuGetProductInfo(sczGuid, wzProperty, &value.sczValue);
+        if (HRESULT_FROM_WIN32(ERROR_UNKNOWN_PROPERTY) == hr)
+        {
+            // product state is available only through MsiGetProductInfoEx
+            // What if there is a hidden variable in sczGuid?
+            LogStringLine(REPORT_VERBOSE, "Trying per-machine extended info for property '%ls' for product: %ls", wzProperty, sczGuid);
+            hr = WiuGetProductInfoEx(sczGuid, NULL, MSIINSTALLCONTEXT_MACHINE, wzProperty, &value.sczValue);
+
+            // if not in per-machine context, try per-user (unmanaged)
+            if (HRESULT_FROM_WIN32(ERROR_UNKNOWN_PRODUCT) == hr)
+            {
+                // What if there is a hidden variable in sczGuid?
+                LogStringLine(REPORT_STANDARD, "Trying per-user extended info for property '%ls' for product: %ls", wzProperty, sczGuid);
+                hr = WiuGetProductInfoEx(sczGuid, NULL, MSIINSTALLCONTEXT_USERUNMANAGED, wzProperty, &value.sczValue);
+            }
+        }
+    }
+
+    if (HRESULT_FROM_WIN32(ERROR_UNKNOWN_PRODUCT) == hr)
+    {
+        // What if there is a hidden variable in sczGuid?
+        LogStringLine(REPORT_STANDARD, "Product or related product not found: %ls", sczGuid);
+
+        // set value to indicate absent
+        switch (pSearch->MsiProductSearch.Type)
+        {
+        case BURN_MSI_PRODUCT_SEARCH_TYPE_ASSIGNMENT: __fallthrough;
+        case BURN_MSI_PRODUCT_SEARCH_TYPE_VERSION:
+            value.Type = BURN_VARIANT_TYPE_NUMERIC;
+            value.llValue = 0;
+            break;
+        case BURN_MSI_PRODUCT_SEARCH_TYPE_LANGUAGE:
+            // is supposed to remain empty
+            break;
+        case BURN_MSI_PRODUCT_SEARCH_TYPE_STATE:
+            value.Type = BURN_VARIANT_TYPE_NUMERIC;
+            value.llValue = INSTALLSTATE_ABSENT;
+            break;
+        }
+
+        hr = S_OK;
+    }
+    ExitOnFailure(hr, "Failed to get product info.");
+
+    // change value type
+    switch (pSearch->MsiProductSearch.Type)
+    {
+    case BURN_MSI_PRODUCT_SEARCH_TYPE_VERSION:
+        type = BURN_VARIANT_TYPE_VERSION;
+        break;
+    case BURN_MSI_PRODUCT_SEARCH_TYPE_LANGUAGE:
+        type = BURN_VARIANT_TYPE_STRING;
+        break;
+    case BURN_MSI_PRODUCT_SEARCH_TYPE_STATE: __fallthrough;
+    case BURN_MSI_PRODUCT_SEARCH_TYPE_ASSIGNMENT:
+        type = BURN_VARIANT_TYPE_NUMERIC;
+        break;
+    }
+    hr = BVariantChangeType(&value, type);
+    ExitOnFailure(hr, "Failed to change value type.");
+
+    // Set variable as a literal.
+    hr = VariableSetLiteralVariant(pVariables, pSearch->sczVariable, &value);
+    ExitOnFailure(hr, "Failed to set variable.");
+
+LExit:
+    if (FAILED(hr))
+    {
+        LogStringLine(REPORT_STANDARD, "MsiProductSearch failed: ID '%ls', HRESULT 0x%x", pSearch->sczKey, hr);
+    }
+
+    StrSecureZeroFreeString(sczGuid);
+    ReleaseStrArray(rgsczRelatedProductCodes, dwRelatedProducts);
+    BVariantUninitialize(&value);
+
+    return hr;
+}
+
+static HRESULT MsiFeatureSearch(
+    __in BURN_SEARCH* pSearch,
+    __in BURN_VARIABLES* /*pVariables*/
+    )
+{
+    HRESULT hr = E_NOTIMPL;
+
+//LExit:
+    if (FAILED(hr))
+    {
+        LogStringLine(REPORT_STANDARD, "MsiFeatureSearch failed: ID '%ls', HRESULT 0x%x", pSearch->sczKey, hr);
+    }
+
+    return hr;
+}
diff --git a/src/engine/search.h b/src/engine/search.h
new file mode 100644
index 00000000..65dfb18f
--- /dev/null
+++ b/src/engine/search.h
@@ -0,0 +1,152 @@
+#pragma once
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+
+// constants
+
+enum BURN_SEARCH_TYPE
+{
+    BURN_SEARCH_TYPE_NONE,
+    BURN_SEARCH_TYPE_DIRECTORY,
+    BURN_SEARCH_TYPE_FILE,
+    BURN_SEARCH_TYPE_REGISTRY,
+    BURN_SEARCH_TYPE_MSI_COMPONENT,
+    BURN_SEARCH_TYPE_MSI_PRODUCT,
+    BURN_SEARCH_TYPE_MSI_FEATURE,
+};
+
+enum BURN_DIRECTORY_SEARCH_TYPE
+{
+    BURN_DIRECTORY_SEARCH_TYPE_NONE,
+    BURN_DIRECTORY_SEARCH_TYPE_EXISTS,
+    BURN_DIRECTORY_SEARCH_TYPE_PATH,
+};
+
+enum BURN_FILE_SEARCH_TYPE
+{
+    BURN_FILE_SEARCH_TYPE_NONE,
+    BURN_FILE_SEARCH_TYPE_EXISTS,
+    BURN_FILE_SEARCH_TYPE_VERSION,
+    BURN_FILE_SEARCH_TYPE_PATH,
+};
+
+enum BURN_REGISTRY_SEARCH_TYPE
+{
+    BURN_REGISTRY_SEARCH_TYPE_NONE,
+    BURN_REGISTRY_SEARCH_TYPE_EXISTS,
+    BURN_REGISTRY_SEARCH_TYPE_VALUE,
+};
+
+enum BURN_MSI_COMPONENT_SEARCH_TYPE
+{
+    BURN_MSI_COMPONENT_SEARCH_TYPE_NONE,
+    BURN_MSI_COMPONENT_SEARCH_TYPE_KEYPATH,
+    BURN_MSI_COMPONENT_SEARCH_TYPE_STATE,
+    BURN_MSI_COMPONENT_SEARCH_TYPE_DIRECTORY,
+};
+
+enum BURN_MSI_PRODUCT_SEARCH_TYPE
+{
+    BURN_MSI_PRODUCT_SEARCH_TYPE_NONE,
+    BURN_MSI_PRODUCT_SEARCH_TYPE_VERSION,
+    BURN_MSI_PRODUCT_SEARCH_TYPE_LANGUAGE,
+    BURN_MSI_PRODUCT_SEARCH_TYPE_STATE,
+    BURN_MSI_PRODUCT_SEARCH_TYPE_ASSIGNMENT,
+};
+
+enum BURN_MSI_PRODUCT_SEARCH_GUID_TYPE
+{
+    BURN_MSI_PRODUCT_SEARCH_GUID_TYPE_NONE,
+    BURN_MSI_PRODUCT_SEARCH_GUID_TYPE_PRODUCTCODE,
+    BURN_MSI_PRODUCT_SEARCH_GUID_TYPE_UPGRADECODE
+};
+
+enum BURN_MSI_FEATURE_SEARCH_TYPE
+{
+    BURN_MSI_FEATURE_SEARCH_TYPE_NONE,
+    BURN_MSI_FEATURE_SEARCH_TYPE_STATE,
+};
+
+
+// structs
+
+typedef struct _BURN_SEARCH
+{
+    LPWSTR sczKey;
+    LPWSTR sczVariable;
+    LPWSTR sczCondition;
+
+    BURN_SEARCH_TYPE Type;
+    union
+    {
+        struct
+        {
+            BURN_DIRECTORY_SEARCH_TYPE Type;
+            LPWSTR sczPath;
+        } DirectorySearch;
+        struct
+        {
+            BURN_FILE_SEARCH_TYPE Type;
+            LPWSTR sczPath;
+        } FileSearch;
+        struct
+        {
+            BURN_REGISTRY_SEARCH_TYPE Type;
+            BURN_VARIANT_TYPE VariableType;
+            HKEY hRoot;
+            LPWSTR sczKey;
+            LPWSTR sczValue;
+            BOOL fWin64;
+            BOOL fExpandEnvironment;
+        } RegistrySearch;
+        struct
+        {
+            BURN_MSI_COMPONENT_SEARCH_TYPE Type;
+            LPWSTR sczProductCode;
+            LPWSTR sczComponentId;
+        } MsiComponentSearch;
+        struct
+        {
+            BURN_MSI_PRODUCT_SEARCH_TYPE Type;
+            BURN_MSI_PRODUCT_SEARCH_GUID_TYPE GuidType;
+            LPWSTR sczGuid;
+        } MsiProductSearch;
+        struct
+        {
+            BURN_MSI_FEATURE_SEARCH_TYPE Type;
+            LPWSTR sczProductCode;
+            LPWSTR sczFeatureId;
+        } MsiFeatureSearch;
+    };
+} BURN_SEARCH;
+
+typedef struct _BURN_SEARCHES
+{
+    BURN_SEARCH* rgSearches;
+    DWORD cSearches;
+} BURN_SEARCHES;
+
+
+// function declarations
+
+HRESULT SearchesParseFromXml(
+    __in BURN_SEARCHES* pSearches,
+    __in IXMLDOMNode* pixnBundle
+    );
+HRESULT SearchesExecute(
+    __in BURN_SEARCHES* pSearches,
+    __in BURN_VARIABLES* pVariables
+    );
+void SearchesUninitialize(
+    __in BURN_SEARCHES* pSearches
+    );
+
+
+#if defined(__cplusplus)
+}
+#endif
diff --git a/src/engine/section.cpp b/src/engine/section.cpp
new file mode 100644
index 00000000..3adcdd14
--- /dev/null
+++ b/src/engine/section.cpp
@@ -0,0 +1,399 @@
+// 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.
+
+#include "precomp.h"
+
+
+// constants
+
+// If these defaults ever change, be sure to update constants in burn\stub\StubSection.cpp as well.
+#define BURN_SECTION_NAME ".wixburn"
+#define BURN_SECTION_MAGIC 0x00f14300
+#define BURN_SECTION_VERSION 0x00000002
+#define MANIFEST_CABINET_TOKEN L"0"
+
+// structs
+typedef struct _BURN_SECTION_HEADER
+{
+    DWORD dwMagic;
+    DWORD dwVersion;
+
+    GUID guidBundleId;
+
+    DWORD dwStubSize;
+    DWORD dwOriginalChecksum;
+    DWORD dwOriginalSignatureOffset;
+    DWORD dwOriginalSignatureSize;
+
+    DWORD dwFormat;
+    DWORD cContainers;
+    DWORD rgcbContainers[1];
+} BURN_SECTION_HEADER;
+
+static HRESULT VerifySectionMatchesMemoryPEHeader(
+    __in REFGUID pSection
+    );
+
+
+extern "C" HRESULT SectionInitialize(
+    __in BURN_SECTION* pSection,
+    __in HANDLE hEngineFile,
+    __in HANDLE hSourceEngineFile
+    )
+{
+    HRESULT hr = S_OK;
+    DWORD cbRead = 0;
+    LARGE_INTEGER li = { };
+    LONGLONG llSize = 0;
+    IMAGE_DOS_HEADER dosHeader = { };
+    IMAGE_NT_HEADERS ntHeader = { };
+    DWORD dwChecksumOffset = 0;
+    DWORD dwCertificateTableOffset = 0;
+    DWORD dwSignatureOffset = 0;
+    DWORD cbSignature = 0;
+    IMAGE_SECTION_HEADER sectionHeader = { };
+    DWORD dwOriginalChecksumAndSignatureOffset = 0;
+    BURN_SECTION_HEADER* pBurnSectionHeader = NULL;
+
+    pSection->hEngineFile = hEngineFile;
+    ExitOnInvalidHandleWithLastError(pSection->hEngineFile, hr, "Failed to open handle to engine process path.");
+
+    pSection->hSourceEngineFile = INVALID_HANDLE_VALUE == hSourceEngineFile ? hEngineFile : hSourceEngineFile;
+
+    //
+    // First, make sure we have a valid DOS signature.
+    //
+    if (!::SetFilePointerEx(pSection->hEngineFile, li, NULL, FILE_BEGIN))
+    {
+        ExitWithLastError(hr, "Failed to seek to start of file.");
+    }
+
+    // read DOS header
+    if (!::ReadFile(pSection->hEngineFile, &dosHeader, sizeof(IMAGE_DOS_HEADER), &cbRead, NULL))
+    {
+        ExitWithLastError(hr, "Failed to read DOS header.");
+    }
+    else if (sizeof(IMAGE_DOS_HEADER) > cbRead || IMAGE_DOS_SIGNATURE != dosHeader.e_magic)
+    {
+        hr = HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
+        ExitOnRootFailure(hr, "Failed to find valid DOS image header in buffer.");
+    }
+
+    //
+    // Now, make sure we have a valid NT signature.
+    //
+
+    // seek to new header
+    li.QuadPart = dosHeader.e_lfanew;
+    if (!::SetFilePointerEx(pSection->hEngineFile, li, NULL, FILE_BEGIN))
+    {
+        ExitWithLastError(hr, "Failed to seek to NT header.");
+    }
+
+    // read NT header
+    if (!::ReadFile(pSection->hEngineFile, &ntHeader, sizeof(IMAGE_NT_HEADERS) - sizeof(IMAGE_OPTIONAL_HEADER), &cbRead, NULL))
+    {
+        ExitWithLastError(hr, "Failed to read NT header.");
+    }
+    else if ((sizeof(IMAGE_NT_HEADERS) - sizeof(IMAGE_OPTIONAL_HEADER)) > cbRead || IMAGE_NT_SIGNATURE != ntHeader.Signature)
+    {
+        hr = HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
+        ExitOnRootFailure(hr, "Failed to find valid NT image header in buffer.");
+    }
+
+    // Get the table offsets.
+    dwChecksumOffset = dosHeader.e_lfanew + sizeof(IMAGE_NT_HEADERS) - sizeof(IMAGE_OPTIONAL_HEADER) + (sizeof(DWORD) * 16);
+    dwCertificateTableOffset = dosHeader.e_lfanew + sizeof(IMAGE_NT_HEADERS) - (sizeof(IMAGE_DATA_DIRECTORY) * (IMAGE_NUMBEROF_DIRECTORY_ENTRIES - IMAGE_DIRECTORY_ENTRY_SECURITY));
+
+    // Seek into the certificate table to get the signature size.
+    li.QuadPart = dwCertificateTableOffset;
+    if (!::SetFilePointerEx(pSection->hEngineFile, li, NULL, FILE_BEGIN))
+    {
+        ExitWithLastError(hr, "Failed to seek to section info.");
+    }
+
+    if (!::ReadFile(pSection->hEngineFile, &dwSignatureOffset, sizeof(dwSignatureOffset), &cbRead, NULL))
+    {
+        ExitWithLastError(hr, "Failed to read signature offset.");
+    }
+
+    if (!::ReadFile(pSection->hEngineFile, &cbSignature, sizeof(cbSignature), &cbRead, NULL))
+    {
+        ExitWithLastError(hr, "Failed to read signature size.");
+    }
+
+    //
+    // Finally, get into the section table and look for the Burn section info.
+    //
+
+    // seek past optional headers
+    li.QuadPart = dosHeader.e_lfanew + sizeof(IMAGE_NT_HEADERS) - sizeof(IMAGE_OPTIONAL_HEADER) + ntHeader.FileHeader.SizeOfOptionalHeader;
+    if (!::SetFilePointerEx(pSection->hEngineFile, li, NULL, FILE_BEGIN))
+    {
+        ExitWithLastError(hr, "Failed to seek past optional headers.");
+    }
+
+    // read sections one by one until we find our section
+    for (DWORD i = 0; ; ++i)
+    {
+        // read section
+        if (!::ReadFile(pSection->hEngineFile, &sectionHeader, sizeof(IMAGE_SECTION_HEADER), &cbRead, NULL))
+        {
+            ExitWithLastError(hr, "Failed to read image section header, index: %u", i);
+        }
+        if (sizeof(IMAGE_SECTION_HEADER) > cbRead)
+        {
+            hr = HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
+            ExitOnRootFailure(hr, "Failed to read complete image section header, index: %u", i);
+        }
+
+        // compare header name
+        C_ASSERT(sizeof(sectionHeader.Name) == sizeof(BURN_SECTION_NAME) - 1);
+        if (0 == memcmp(sectionHeader.Name, BURN_SECTION_NAME, sizeof(sectionHeader.Name)))
+        {
+            break;
+        }
+
+        // fail if we hit the end
+        if (i + 1 >= ntHeader.FileHeader.NumberOfSections)
+        {
+            hr = HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
+            ExitOnRootFailure(hr, "Failed to find Burn section.");
+        }
+    }
+
+    //
+    // We've arrived at the section info.
+    //
+
+    // check size of section
+    if (sizeof(BURN_SECTION_HEADER) > sectionHeader.SizeOfRawData)
+    {
+        hr = HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
+        ExitOnRootFailure(hr, "Failed to read section info, data to short: %u", sectionHeader.SizeOfRawData);
+    }
+
+    // allocate buffer for section info
+    pBurnSectionHeader = (BURN_SECTION_HEADER*)MemAlloc(sectionHeader.SizeOfRawData, TRUE);
+    ExitOnNull(pBurnSectionHeader, hr, E_OUTOFMEMORY, "Failed to allocate buffer for section info.");
+
+    // seek to section info
+    li.QuadPart = sectionHeader.PointerToRawData;
+    if (!::SetFilePointerEx(pSection->hEngineFile, li, NULL, FILE_BEGIN))
+    {
+        ExitWithLastError(hr, "Failed to seek to section info.");
+    }
+
+    // Note the location of original checksum and signature information in the burn section header.
+    dwOriginalChecksumAndSignatureOffset = sectionHeader.PointerToRawData + (reinterpret_cast<LPBYTE>(&pBurnSectionHeader->dwOriginalChecksum) - reinterpret_cast<LPBYTE>(pBurnSectionHeader));
+
+    // read section info
+    if (!::ReadFile(pSection->hEngineFile, pBurnSectionHeader, sectionHeader.SizeOfRawData, &cbRead, NULL))
+    {
+        ExitWithLastError(hr, "Failed to read section info.");
+    }
+    else if (sectionHeader.SizeOfRawData > cbRead)
+    {
+        hr = HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
+        ExitOnRootFailure(hr, "Failed to read complete section info.");
+    }
+
+    // validate version of section info
+    if (BURN_SECTION_VERSION != pBurnSectionHeader->dwVersion)
+    {
+        hr = HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
+        ExitOnRootFailure(hr, "Failed to read section info, unsupported version: %08x", pBurnSectionHeader->dwVersion);
+    }
+
+    hr = FileSizeByHandle(pSection->hSourceEngineFile, &llSize);
+    ExitOnFailure(hr, "Failed to get total size of bundle.");
+
+    pSection->cbStub = pBurnSectionHeader->dwStubSize;
+
+    // If there is an original signature use that to determine the engine size.
+    if (pBurnSectionHeader->dwOriginalSignatureOffset)
+    {
+        pSection->cbEngineSize = pBurnSectionHeader->dwOriginalSignatureOffset + pBurnSectionHeader->dwOriginalSignatureSize;
+    }
+    else if (dwSignatureOffset) // if there is a signature, use it.
+    {
+        pSection->cbEngineSize = dwSignatureOffset + cbSignature;
+    }
+    else // just use the stub and UX container as the size of the engine.
+    {
+        pSection->cbEngineSize = pSection->cbStub + pBurnSectionHeader->rgcbContainers[0];
+    }
+
+    pSection->qwBundleSize = static_cast<DWORD64>(llSize);
+
+    pSection->dwChecksumOffset = dwChecksumOffset;
+    pSection->dwCertificateTableOffset = dwCertificateTableOffset;
+    pSection->dwOriginalChecksumAndSignatureOffset = dwOriginalChecksumAndSignatureOffset;
+
+    pSection->dwOriginalChecksum = pBurnSectionHeader->dwOriginalChecksum;
+    pSection->dwOriginalSignatureOffset = pBurnSectionHeader->dwOriginalSignatureOffset;
+    pSection->dwOriginalSignatureSize = pBurnSectionHeader->dwOriginalSignatureSize;
+
+    pSection->dwFormat = pBurnSectionHeader->dwFormat;
+    pSection->cContainers = pBurnSectionHeader->cContainers;
+    pSection->rgcbContainers = (DWORD*)MemAlloc(sizeof(DWORD) * pSection->cContainers, TRUE);
+    ExitOnNull(pSection->rgcbContainers, hr, E_OUTOFMEMORY, "Failed to allocate memory for container sizes.");
+
+    memcpy(pSection->rgcbContainers, pBurnSectionHeader->rgcbContainers, sizeof(DWORD) * pSection->cContainers);
+
+    // TODO: verify more than just the GUID.
+    hr = VerifySectionMatchesMemoryPEHeader(pBurnSectionHeader->guidBundleId);
+    ExitOnRootFailure(hr, "PE Header from file didn't match PE Header in memory.");
+
+LExit:
+    ReleaseMem(pBurnSectionHeader);
+
+    return hr;
+}
+
+extern "C" void SectionUninitialize(
+    __out BURN_SECTION* pSection
+    )
+{
+    ReleaseMem(pSection->rgcbContainers);
+    memset(pSection, 0, sizeof(BURN_SECTION));
+}
+
+extern "C" HRESULT SectionGetAttachedContainerInfo(
+    __in BURN_SECTION* pSection,
+    __in DWORD iContainerIndex,
+    __in DWORD dwExpectedType,
+    __out DWORD64* pqwOffset,
+    __out DWORD64* pqwSize,
+    __out BOOL* pfPresent
+    )
+{
+    HRESULT hr = S_OK;
+
+    // validate container info
+    if (iContainerIndex >= pSection->cContainers)
+    {
+        hr = HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
+        ExitOnRootFailure(hr, "Failed to find container info, too few elements: %u", pSection->cContainers);
+    }
+    else if (dwExpectedType != pSection->dwFormat)
+    {
+        hr = HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
+        ExitOnRootFailure(hr, "Unexpected container format.");
+    }
+
+    // If we are asking for the UX container, find it right after the stub.
+    if (0 == iContainerIndex)
+    {
+        *pqwOffset = pSection->cbStub;
+    }
+    else // attached containers start after the whole engine.
+    {
+        *pqwOffset = pSection->cbEngineSize;
+        for (DWORD i = 1; i < iContainerIndex; ++i)
+        {
+            *pqwOffset += pSection->rgcbContainers[i];
+        }
+    }
+
+    *pqwSize = pSection->rgcbContainers[iContainerIndex];
+    *pfPresent = (*pqwOffset + *pqwSize) <= pSection->qwBundleSize;
+
+    AssertSz(*pfPresent || pSection->qwBundleSize <= *pqwOffset, "An attached container should either be present or completely absent from the bundle. Found a case where the attached container is partially present which is wrong.");
+
+LExit:
+    return hr;
+}
+
+HRESULT VerifySectionMatchesMemoryPEHeader(
+    __in REFGUID pBundleId
+    )
+{
+    HRESULT hr = S_OK;
+    BYTE* pbPEHeader = NULL;
+    PIMAGE_DOS_HEADER pDosHeader = NULL;
+    PIMAGE_NT_HEADERS pNtHeader = NULL;
+    PIMAGE_SECTION_HEADER pSections = NULL;
+    PIMAGE_SECTION_HEADER pSectionHeader = NULL;
+    BURN_SECTION_HEADER* pBurnSectionHeader = NULL;
+
+    pbPEHeader = reinterpret_cast<BYTE*>(::GetModuleHandleW(NULL));
+    ExitOnNullWithLastError(pbPEHeader, hr, "Failed to get module handle to process.");
+
+    //
+    // First, make sure we have a valid DOS signature.
+    //
+
+    pDosHeader = reinterpret_cast<PIMAGE_DOS_HEADER>(pbPEHeader);
+    if (IMAGE_DOS_SIGNATURE != pDosHeader->e_magic)
+    {
+        hr = HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
+        ExitOnRootFailure(hr, "Failed to find valid DOS image header in buffer.");
+    }
+
+    //
+    // Now, make sure we have a valid NT signature.
+    //
+
+    pNtHeader = reinterpret_cast<PIMAGE_NT_HEADERS>(pbPEHeader + pDosHeader->e_lfanew);
+    if (IMAGE_NT_SIGNATURE != pNtHeader->Signature)
+    {
+        hr = HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
+        ExitOnRootFailure(hr, "Failed to find valid NT image header in buffer.");
+    }
+
+    //
+    // Finally, get into the section table and look for the Burn section info.
+    //
+
+    pSections = reinterpret_cast<PIMAGE_SECTION_HEADER>(pbPEHeader + pDosHeader->e_lfanew + sizeof(IMAGE_NT_HEADERS) - sizeof(IMAGE_OPTIONAL_HEADER) + pNtHeader->FileHeader.SizeOfOptionalHeader);
+
+    // Read sections one by one until we find our section.
+    for (DWORD i = 0; ; ++i)
+    {
+        pSectionHeader = pSections + i;
+
+        // Compare header name.
+        C_ASSERT(sizeof(pSectionHeader->Name) == sizeof(BURN_SECTION_NAME) - 1);
+        if (0 == memcmp(pSectionHeader->Name, BURN_SECTION_NAME, sizeof(pSectionHeader->Name)))
+        {
+            break;
+        }
+
+        // Fail if we hit the end.
+        if (i + 1 >= pNtHeader->FileHeader.NumberOfSections)
+        {
+            hr = HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
+            ExitOnRootFailure(hr, "Failed to find Burn section.");
+        }
+    }
+
+    //
+    // We've arrived at the section info.
+    //
+
+    // Check size of section.
+    if (sizeof(BURN_SECTION_HEADER) > pSectionHeader->SizeOfRawData)
+    {
+        hr = HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
+        ExitOnRootFailure(hr, "Failed to read section info, data to short: %u", pSectionHeader->SizeOfRawData);
+    }
+
+    // Get Burn section info.
+    pBurnSectionHeader = reinterpret_cast<BURN_SECTION_HEADER*>(pbPEHeader + pSectionHeader->VirtualAddress);
+
+    // Validate version of section info.
+    if (BURN_SECTION_VERSION != pBurnSectionHeader->dwVersion)
+    {
+        hr = HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
+        ExitOnRootFailure(hr, "Failed to read section info, unsupported version: %08x", pBurnSectionHeader->dwVersion);
+    }
+
+    if (!::IsEqualGUID(pBundleId, pBurnSectionHeader->guidBundleId))
+    {
+        hr = E_INVALIDDATA;
+        ExitOnRootFailure(hr, "Bundle guid didn't match the guid in the PE Header in memory.");
+    }
+
+LExit:
+    return hr;
+}
diff --git a/src/engine/section.h b/src/engine/section.h
new file mode 100644
index 00000000..78331469
--- /dev/null
+++ b/src/engine/section.h
@@ -0,0 +1,54 @@
+#pragma once
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+
+// structs
+
+typedef struct _BURN_SECTION
+{
+    HANDLE hEngineFile;
+    HANDLE hSourceEngineFile;
+
+    DWORD cbStub;
+    DWORD cbEngineSize;     // stub + UX container + original certficiate
+    DWORD64 qwBundleSize;   // stub + UX container + original certificate [+ attached containers* + final certificate]
+
+    DWORD dwChecksumOffset;
+    DWORD dwCertificateTableOffset;
+    DWORD dwOriginalChecksumAndSignatureOffset;
+
+    DWORD dwOriginalChecksum;
+    DWORD dwOriginalSignatureOffset;
+    DWORD dwOriginalSignatureSize;
+
+    DWORD dwFormat;
+    DWORD cContainers;
+    DWORD* rgcbContainers;
+} BURN_SECTION;
+
+
+HRESULT SectionInitialize(
+    __in BURN_SECTION* pSection,
+    __in HANDLE hEngineFile,
+    __in HANDLE hSourceEngineFile
+    );
+void SectionUninitialize(
+    __in BURN_SECTION* pSection
+    );
+HRESULT SectionGetAttachedContainerInfo(
+    __in BURN_SECTION* pSection,
+    __in DWORD iContainerIndex,
+    __in DWORD dwExpectedType,
+    __out DWORD64* pqwOffset,
+    __out DWORD64* pqwSize,
+    __out BOOL* pfPresent
+    );
+
+#if defined(__cplusplus)
+}
+#endif
diff --git a/src/engine/splashscreen.cpp b/src/engine/splashscreen.cpp
new file mode 100644
index 00000000..1f95886a
--- /dev/null
+++ b/src/engine/splashscreen.cpp
@@ -0,0 +1,316 @@
+// 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.
+
+#include "precomp.h"
+
+using namespace Gdiplus;
+
+#define BURN_SPLASHSCREEN_CLASS_WINDOW L"WixBurnSplashScreen"
+#define IDB_SPLASHSCREEN 1
+
+// struct
+
+struct SPLASHSCREEN_INFO
+{
+    Bitmap* pBitmap;
+    Point pt;
+    Size size;
+};
+
+struct SPLASHSCREEN_CONTEXT
+{
+    HANDLE hIntializedEvent;
+    HINSTANCE hInstance;
+    LPCWSTR wzCaption;
+
+    HWND* pHwnd;
+};
+
+// internal function definitions
+
+static DWORD WINAPI ThreadProc(
+    __in LPVOID pvContext
+    );
+static LRESULT CALLBACK WndProc(
+    __in HWND hWnd,
+    __in UINT uMsg,
+    __in WPARAM wParam,
+    __in LPARAM lParam
+    );
+static void OnPaint(
+    __in HDC hdc,
+    __in SPLASHSCREEN_INFO* pSplashScreen
+    );
+static HRESULT LoadSplashScreen(
+    __in HMODULE hInstance,
+    __in SPLASHSCREEN_INFO* pSplashScreen
+    );
+
+
+// function definitions
+
+extern "C" void SplashScreenCreate(
+    __in HINSTANCE hInstance,
+    __in_z_opt LPCWSTR wzCaption,
+    __out HWND* pHwnd
+    )
+{
+    HRESULT hr = S_OK;
+    SPLASHSCREEN_CONTEXT context = { };
+    HANDLE rgSplashScreenEvents[2] = { };
+    DWORD dwSplashScreenThreadId = 0;
+
+    rgSplashScreenEvents[0] = ::CreateEventW(NULL, TRUE, FALSE, NULL);
+    ExitOnNullWithLastError(rgSplashScreenEvents[0], hr, "Failed to create modal event.");
+
+    // create splash screen thread.
+    context.hIntializedEvent = rgSplashScreenEvents[0];
+    context.hInstance = hInstance;
+    context.wzCaption = wzCaption;
+    context.pHwnd = pHwnd;
+
+    rgSplashScreenEvents[1] = ::CreateThread(NULL, 0, ThreadProc, &context, 0, &dwSplashScreenThreadId);
+    ExitOnNullWithLastError(rgSplashScreenEvents[1], hr, "Failed to create UI thread.");
+
+    // It doesn't really matter if the thread gets initialized (WAIT_OBJECT_0) or fails and exits
+    // prematurely (WAIT_OBJECT_0 + 1), we just want to wait long enough for one of those two
+    // events to happen.
+    ::WaitForMultipleObjects(countof(rgSplashScreenEvents), rgSplashScreenEvents, FALSE, INFINITE);
+
+LExit:
+    ReleaseHandle(rgSplashScreenEvents[1]);
+    ReleaseHandle(rgSplashScreenEvents[0]);
+}
+
+extern "C" HRESULT SplashScreenDisplayError(
+    __in BOOTSTRAPPER_DISPLAY display,
+    __in_z LPCWSTR wzBundleName,
+    __in HRESULT hrError
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR sczDisplayString = NULL;
+
+    hr = StrAllocFromError(&sczDisplayString, hrError, NULL);
+    ExitOnFailure(hr, "Failed to allocate string to display error message");
+
+    Trace(REPORT_STANDARD, "Error message displayed because: %ls", sczDisplayString);
+
+    if (BOOTSTRAPPER_DISPLAY_NONE == display || BOOTSTRAPPER_DISPLAY_PASSIVE == display || BOOTSTRAPPER_DISPLAY_EMBEDDED == display)
+    {
+        // Don't display the error dialog in these modes
+        ExitFunction1(hr = S_OK);
+    }
+
+    ::MessageBoxW(NULL, sczDisplayString, wzBundleName, MB_OK | MB_ICONERROR | MB_SYSTEMMODAL);
+
+LExit:
+    ReleaseStr(sczDisplayString);
+
+    return hr;
+}
+
+
+static DWORD WINAPI ThreadProc(
+    __in LPVOID pvContext
+    )
+{
+    HRESULT hr = S_OK;
+
+    ULONG_PTR token = 0;
+    GdiplusStartupInput input;
+    GdiplusStartupOutput output = { };
+
+    SPLASHSCREEN_CONTEXT* pContext = static_cast<SPLASHSCREEN_CONTEXT*>(pvContext);
+    SPLASHSCREEN_INFO splashScreen = { };
+
+    WNDCLASSW wc = { };
+    BOOL fRegistered = TRUE;
+    HWND hWnd = NULL;
+
+    BOOL fRet = FALSE;
+    MSG msg = { };
+
+    input.GdiplusVersion = 1;
+
+    hr = GdipInitialize(&input, &token, &output);
+    ExitOnFailure(hr, "Failed to initialize GDI+.");
+
+    hr = LoadSplashScreen(pContext->hInstance, &splashScreen);
+    ExitOnFailure(hr, "Failed to load splash screen.");
+
+    // Register the window class and create the window.
+    wc.lpfnWndProc = WndProc;
+    wc.hInstance = pContext->hInstance;
+    wc.hCursor = ::LoadCursorW(NULL, (LPCWSTR)IDC_ARROW);
+    wc.lpszClassName = BURN_SPLASHSCREEN_CLASS_WINDOW;
+    if (!::RegisterClassW(&wc))
+    {
+        ExitWithLastError(hr, "Failed to register window.");
+    }
+
+    fRegistered = TRUE;
+
+    hWnd = ::CreateWindowExW(WS_EX_TOOLWINDOW, wc.lpszClassName, pContext->wzCaption, WS_POPUP | WS_VISIBLE, splashScreen.pt.X, splashScreen.pt.Y, splashScreen.size.Width, splashScreen.size.Height, HWND_DESKTOP, NULL, pContext->hInstance, &splashScreen);
+    ExitOnNullWithLastError(hWnd, hr, "Failed to create window.");
+
+    // Return the splash screen window and free the main thread waiting for us to be initialized.
+    *pContext->pHwnd = hWnd;
+    ::SetEvent(pContext->hIntializedEvent);
+
+    // Pump messages until the bootstrapper application destroys the window.
+    while (0 != (fRet = ::GetMessageW(&msg, NULL, 0, 0)))
+    {
+        if (-1 == fRet)
+        {
+            hr = E_UNEXPECTED;
+            ExitOnFailure(hr, "Unexpected return value from message pump.");
+        }
+        else if (!::IsDialogMessageW(hWnd, &msg))
+        {
+            ::TranslateMessage(&msg);
+            ::DispatchMessageW(&msg);
+        }
+    }
+
+LExit:
+    if (fRegistered)
+    {
+        ::UnregisterClassW(BURN_SPLASHSCREEN_CLASS_WINDOW, pContext->hInstance);
+    }
+
+    if (splashScreen.pBitmap)
+    {
+        delete splashScreen.pBitmap;
+    }
+
+    if (token)
+    {
+        GdipUninitialize(token);
+    }
+
+    return hr;
+}
+
+static LRESULT CALLBACK WndProc(
+    __in HWND hWnd,
+    __in UINT uMsg,
+    __in WPARAM wParam,
+    __in LPARAM lParam
+    )
+{
+    LRESULT lres = 0;
+    SPLASHSCREEN_INFO* pSplashScreen = reinterpret_cast<SPLASHSCREEN_INFO*>(::GetWindowLongW(hWnd, GWLP_USERDATA));
+
+    switch (uMsg)
+    {
+    case WM_NCCREATE:
+        {
+        LPCREATESTRUCTW lpcs = reinterpret_cast<LPCREATESTRUCTW>(lParam);
+        ::SetWindowLongPtrW(hWnd, GWLP_USERDATA, reinterpret_cast<LONG_PTR>(lpcs->lpCreateParams));
+        }
+        break;
+
+    case WM_NCDESTROY:
+        lres = ::DefWindowProcW(hWnd, uMsg, wParam, lParam);
+        ::SetWindowLongPtrW(hWnd, GWLP_USERDATA, 0);
+        return lres;
+
+    case WM_NCHITTEST:
+        return HTCAPTION; // allow window to be moved by grabbing any pixel.
+
+    case WM_DESTROY:
+        ::PostQuitMessage(0);
+        return 0;
+
+    case WM_ERASEBKGND:
+        // The splash screen image will be repainted in its entirety.
+        return 1;
+
+    case WM_PAINT:
+        {
+        PAINTSTRUCT ps = { };
+
+        HDC hdc = BeginPaint(hWnd, &ps);
+        OnPaint(hdc, pSplashScreen);
+        EndPaint(hWnd, &ps);
+        }
+        return 0;
+    }
+
+    return ::DefWindowProcW(hWnd, uMsg, wParam, lParam);
+}
+
+static void OnPaint(
+    __in HDC hdc,
+    __in SPLASHSCREEN_INFO* pSplashScreen
+    )
+{
+    // Use high-quality bicubuc stretching from GDI+ which looks better than GDI.
+    Graphics graphics(hdc);
+    graphics.SetInterpolationMode(InterpolationModeHighQualityBicubic);
+
+    Rect dst(0, 0, pSplashScreen->size.Width, pSplashScreen->size.Height);
+    Status status = graphics.DrawImage(pSplashScreen->pBitmap, dst);
+
+#if DEBUG
+    HRESULT hr = GdipHresultFromStatus(status);
+    TraceError(hr, "Failed to draw splash screen bitmap.");
+#else
+    UNREFERENCED_PARAMETER(status);
+#endif
+}
+
+static HRESULT LoadSplashScreen(
+    __in HMODULE hInstance,
+    __in SPLASHSCREEN_INFO* pSplashScreen
+    )
+{
+    HRESULT hr = S_OK;
+    POINT ptCursor = { };
+    HMONITOR hMonitor = NULL;
+    MONITORINFOEXW mi;
+    HDC hdc = NULL;
+    UINT dpiX = 0;
+    UINT dpiY = 0;
+
+    pSplashScreen->pBitmap = Bitmap::FromResource(hInstance, MAKEINTRESOURCEW(IDB_SPLASHSCREEN));
+    ExitOnNull(pSplashScreen->pBitmap, hr, E_INVALIDDATA, "Failed to find the splash screen bitmap.");
+    ExitOnGdipFailure(pSplashScreen->pBitmap->GetLastStatus(), hr, "Failed to load the splash screen bitmap.");
+
+    pSplashScreen->pt.X = CW_USEDEFAULT;
+    pSplashScreen->pt.Y = CW_USEDEFAULT;
+    pSplashScreen->size.Width = pSplashScreen->pBitmap->GetWidth();
+    pSplashScreen->size.Height = pSplashScreen->pBitmap->GetHeight();
+
+    // Stretch and center the window on the monitor with the mouse.
+    if (::GetCursorPos(&ptCursor))
+    {
+        hMonitor = ::MonitorFromPoint(ptCursor, MONITOR_DEFAULTTONEAREST);
+        if (hMonitor)
+        {
+            ZeroMemory(&mi, sizeof(mi));
+            mi.cbSize = sizeof(mi);
+
+            if (::GetMonitorInfoW(hMonitor, &mi))
+            {
+                hdc = ::CreateDCW(L"DISPLAY", mi.szDevice, NULL, NULL);
+                if (hdc)
+                {
+                    dpiX = ::GetDeviceCaps(hdc, LOGPIXELSX);
+                    dpiY = ::GetDeviceCaps(hdc, LOGPIXELSY);
+
+                    pSplashScreen->size.Width = pSplashScreen->size.Width * dpiX / 96;
+                    pSplashScreen->size.Height = pSplashScreen->size.Height * dpiY / 96;
+
+                    ::ReleaseDC(NULL, hdc);
+                }
+
+                pSplashScreen->pt.X = mi.rcWork.left + (mi.rcWork.right  - mi.rcWork.left - pSplashScreen->size.Width) / 2;
+                pSplashScreen->pt.Y = mi.rcWork.top  + (mi.rcWork.bottom - mi.rcWork.top  - pSplashScreen->size.Height) / 2;
+            }
+        }
+    }
+
+LExit:
+    return hr;
+}
diff --git a/src/engine/splashscreen.h b/src/engine/splashscreen.h
new file mode 100644
index 00000000..8f8817c7
--- /dev/null
+++ b/src/engine/splashscreen.h
@@ -0,0 +1,31 @@
+#pragma once
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+
+// constants
+
+
+// structs
+
+
+// functions
+
+void SplashScreenCreate(
+    __in HINSTANCE hInstance,
+    __in_z_opt LPCWSTR wzCaption,
+    __out HWND* pHwnd
+    );
+HRESULT SplashScreenDisplayError(
+    __in BOOTSTRAPPER_DISPLAY display,
+    __in_z LPCWSTR wzBundleName,
+    __in HRESULT hrError
+    );
+
+#if defined(__cplusplus)
+}
+#endif
diff --git a/src/engine/uithread.cpp b/src/engine/uithread.cpp
new file mode 100644
index 00000000..cf111745
--- /dev/null
+++ b/src/engine/uithread.cpp
@@ -0,0 +1,220 @@
+// 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.
+
+#include "precomp.h"
+
+#define BURN_UITHREAD_CLASS_WINDOW L"WixBurnMessageWindow"
+
+
+// structs
+
+struct UITHREAD_CONTEXT
+{
+    HANDLE hInitializedEvent;
+    HINSTANCE hInstance;
+    BURN_ENGINE_STATE* pEngineState;
+};
+
+struct UITHREAD_INFO
+{
+    BOOL fElevated;
+    BURN_USER_EXPERIENCE* pUserExperience;
+};
+
+
+// internal function declarations
+
+static DWORD WINAPI ThreadProc(
+    __in LPVOID pvContext
+    );
+
+static LRESULT CALLBACK WndProc(
+    __in HWND hWnd,
+    __in UINT uMsg,
+    __in WPARAM wParam,
+    __in LPARAM lParam
+    );
+
+
+// function definitions
+
+HRESULT UiCreateMessageWindow(
+    __in HINSTANCE hInstance,
+    __in BURN_ENGINE_STATE* pEngineState
+    )
+{
+    HRESULT hr = S_OK;
+    HANDLE rgWaitHandles[2] = { };
+    UITHREAD_CONTEXT context = { };
+
+    // Create event to signal after the UI thread / window is initialized.
+    rgWaitHandles[0] = ::CreateEventW(NULL, TRUE, FALSE, NULL);
+    ExitOnNullWithLastError(rgWaitHandles[0], hr, "Failed to create initialization event.");
+
+    // Pass necessary information to create the window.
+    context.hInitializedEvent = rgWaitHandles[0];
+    context.hInstance = hInstance;
+    context.pEngineState = pEngineState;
+
+    // Create our separate UI thread.
+    rgWaitHandles[1] = ::CreateThread(NULL, 0, ThreadProc, &context, 0, NULL);
+    ExitOnNullWithLastError(rgWaitHandles[1], hr, "Failed to create the UI thread.");
+
+    // Wait for either the thread to be initialized or the window to exit / fail prematurely.
+    ::WaitForMultipleObjects(countof(rgWaitHandles), rgWaitHandles, FALSE, INFINITE);
+
+    pEngineState->hMessageWindowThread = rgWaitHandles[1];
+    rgWaitHandles[1] = NULL;
+
+LExit:
+    ReleaseHandle(rgWaitHandles[1]);
+    ReleaseHandle(rgWaitHandles[0]);
+
+    return hr;
+}
+
+void UiCloseMessageWindow(
+    __in BURN_ENGINE_STATE* pEngineState
+    )
+{
+    if (::IsWindow(pEngineState->hMessageWindow))
+    {
+        ::PostMessageW(pEngineState->hMessageWindow, WM_CLOSE, 0, 0);
+
+        // Give the window 15 seconds to close because if it stays open it can prevent
+        // the engine from starting a reboot (should a reboot actually be necessary).
+        ::WaitForSingleObject(pEngineState->hMessageWindowThread, 15 * 1000);
+    }
+}
+
+
+// internal function definitions
+
+static DWORD WINAPI ThreadProc(
+    __in LPVOID pvContext
+    )
+{
+    HRESULT hr = S_OK;
+    UITHREAD_CONTEXT* pContext = static_cast<UITHREAD_CONTEXT*>(pvContext);
+    UITHREAD_INFO info = { };
+
+    WNDCLASSW wc = { };
+    BOOL fRegistered = TRUE;
+    HWND hWnd = NULL;
+
+    BOOL fRet = FALSE;
+    MSG msg = { };
+
+    BURN_ENGINE_STATE* pEngineState = pContext->pEngineState;
+    BOOL fElevated = BURN_MODE_ELEVATED == pContext->pEngineState->mode;
+
+    // If elevated, set up the thread local storage to store the correct pipe to communicate logging.
+    if (fElevated)
+    {
+        Assert(TLS_OUT_OF_INDEXES != pEngineState->dwElevatedLoggingTlsId);
+
+        if (!::TlsSetValue(pEngineState->dwElevatedLoggingTlsId, pEngineState->companionConnection.hPipe))
+        {
+            // If the function failed we cannot write to the pipe so just terminate.
+            ExitFunction1(hr = E_INVALIDSTATE);
+        }
+    }
+
+    wc.lpfnWndProc = WndProc;
+    wc.hInstance = pContext->hInstance;
+    wc.lpszClassName = BURN_UITHREAD_CLASS_WINDOW;
+
+    if (!::RegisterClassW(&wc))
+    {
+        ExitWithLastError(hr, "Failed to register window.");
+    }
+
+    fRegistered = TRUE;
+
+    info.fElevated = fElevated;
+    info.pUserExperience = &pEngineState->userExperience;
+
+    // Create the window to handle reboots without activating it.
+    hWnd = ::CreateWindowExW(WS_EX_TOOLWINDOW, wc.lpszClassName, NULL, WS_POPUP | WS_VISIBLE, CW_USEDEFAULT, SW_SHOWNA, 0, 0, HWND_DESKTOP, NULL, pContext->hInstance, &info);
+    ExitOnNullWithLastError(hWnd, hr, "Failed to create window.");
+
+    // Persist the window handle and let the caller know we've initialized.
+    pEngineState->hMessageWindow = hWnd;
+    ::SetEvent(pContext->hInitializedEvent);
+
+    // Pump messages until the window is closed.
+    while (0 != (fRet = ::GetMessageW(&msg, NULL, 0, 0)))
+    {
+        if (-1 == fRet)
+        {
+            hr = E_UNEXPECTED;
+            ExitOnFailure(hr, "Unexpected return value from message pump.");
+        }
+        else if (!::IsDialogMessageW(msg.hwnd, &msg))
+        {
+            ::TranslateMessage(&msg);
+            ::DispatchMessageW(&msg);
+        }
+    }
+
+LExit:
+    if (fRegistered)
+    {
+        ::UnregisterClassW(BURN_UITHREAD_CLASS_WINDOW, pContext->hInstance);
+    }
+
+    return hr;
+}
+
+static LRESULT CALLBACK WndProc(
+    __in HWND hWnd,
+    __in UINT uMsg,
+    __in WPARAM wParam,
+    __in LPARAM lParam
+    )
+{
+    switch (uMsg)
+    {
+    case WM_NCCREATE:
+        {
+        LPCREATESTRUCTW lpcs = reinterpret_cast<LPCREATESTRUCTW>(lParam);
+        ::SetWindowLongPtrW(hWnd, GWLP_USERDATA, reinterpret_cast<LONG_PTR>(lpcs->lpCreateParams));
+        break;
+        }
+
+    case WM_NCDESTROY:
+        {
+        LRESULT lRes = ::DefWindowProcW(hWnd, uMsg, wParam, lParam);
+        ::SetWindowLongPtrW(hWnd, GWLP_USERDATA, 0);
+        return lRes;
+        }
+
+    case WM_QUERYENDSESSION:
+        {
+        DWORD dwEndSession = static_cast<DWORD>(lParam);
+        BOOL fCritical = ENDSESSION_CRITICAL & dwEndSession;
+        BOOL fCancel = TRUE;
+        BOOL fRet = FALSE;
+
+        // Always block shutdown in the elevated process, but ask the BA in the non-elevated.
+        UITHREAD_INFO* pInfo = reinterpret_cast<UITHREAD_INFO*>(::GetWindowLongW(hWnd, GWLP_USERDATA));
+        if (!pInfo->fElevated)
+        {
+            // TODO: instead of recommending canceling all non-critical shutdowns, maybe we should only recommend cancel
+            //       when the engine is doing work?
+            fCancel = !fCritical;
+            // TODO: There's a race condition here where the BA may not have been loaded, or already was unloaded.
+            UserExperienceOnSystemShutdown(pInfo->pUserExperience, dwEndSession, &fCancel);
+        }
+
+        fRet = !fCancel;
+        LogId(REPORT_STANDARD, MSG_SYSTEM_SHUTDOWN, LoggingBoolToString(fCritical), LoggingBoolToString(pInfo->fElevated), LoggingBoolToString(fRet));
+        return fRet;
+        }
+
+    case WM_DESTROY:
+        ::PostQuitMessage(0);
+        return 0;
+    }
+
+    return ::DefWindowProcW(hWnd, uMsg, wParam, lParam);
+}
diff --git a/src/engine/uithread.h b/src/engine/uithread.h
new file mode 100644
index 00000000..41168d52
--- /dev/null
+++ b/src/engine/uithread.h
@@ -0,0 +1,23 @@
+#pragma once
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+
+// functions
+
+HRESULT UiCreateMessageWindow(
+    __in HINSTANCE hInstance,
+    __in BURN_ENGINE_STATE* pEngineState
+    );
+
+void UiCloseMessageWindow(
+    __in BURN_ENGINE_STATE* pEngineState
+    );
+
+#if defined(__cplusplus)
+}
+#endif
diff --git a/src/engine/update.cpp b/src/engine/update.cpp
new file mode 100644
index 00000000..b04fa9a4
--- /dev/null
+++ b/src/engine/update.cpp
@@ -0,0 +1,44 @@
+// 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.
+
+#include "precomp.h"
+
+
+// internal function declarations
+
+
+// function definitions
+
+extern "C" HRESULT UpdateParseFromXml(
+    __in BURN_UPDATE* pUpdate,
+    __in IXMLDOMNode* pixnBundle
+    )
+{
+    HRESULT hr = S_OK;
+    IXMLDOMNode* pixnUpdateNode = NULL;
+
+    hr = XmlSelectSingleNode(pixnBundle, L"Update", &pixnUpdateNode);
+    if (S_FALSE == hr)
+    {
+        ExitFunction1(hr = S_OK);
+    }
+    ExitOnFailure(hr, "Failed to select Bundle/Update node.");
+
+    // @Location
+    hr = XmlGetAttributeEx(pixnUpdateNode, L"Location", &pUpdate->sczUpdateSource);
+    ExitOnFailure(hr, "Failed to get Update@Location.");
+
+LExit:
+    ReleaseObject(pixnUpdateNode);
+
+    return hr;
+}
+
+extern "C" void UpdateUninitialize(
+    __in BURN_UPDATE* pUpdate
+    )
+{
+    PackageUninitialize(&pUpdate->package);
+
+    ReleaseStr(pUpdate->sczUpdateSource);
+    memset(pUpdate, 0, sizeof(BURN_UPDATE));
+}
diff --git a/src/engine/update.h b/src/engine/update.h
new file mode 100644
index 00000000..67d40481
--- /dev/null
+++ b/src/engine/update.h
@@ -0,0 +1,33 @@
+#pragma once
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+
+// structs
+
+typedef struct _BURN_UPDATE
+{
+    BOOL fUpdateAvailable;
+    LPWSTR sczUpdateSource;
+
+    BURN_PACKAGE package;
+} BURN_UPDATE;
+
+
+// function declarations
+
+HRESULT UpdateParseFromXml(
+    __in BURN_UPDATE* pUpdate,
+    __in IXMLDOMNode* pixnBundle
+    );
+void UpdateUninitialize(
+    __in BURN_UPDATE* pUpdate
+    );
+
+#if defined(__cplusplus)
+}
+#endif
diff --git a/src/engine/userexperience.cpp b/src/engine/userexperience.cpp
new file mode 100644
index 00000000..8d5271aa
--- /dev/null
+++ b/src/engine/userexperience.cpp
@@ -0,0 +1,2122 @@
+// 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.
+
+#include "precomp.h"
+
+// internal function declarations
+
+static int FilterResult(
+    __in DWORD dwAllowedResults,
+    __in int nResult
+    );
+
+static HRESULT FilterExecuteResult(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in HRESULT hrStatus,
+    __in BOOL fRollback,
+    __in BOOL fCancel,
+    __in LPCWSTR sczEventName
+    );
+
+
+// function definitions
+
+/*******************************************************************
+ UserExperienceParseFromXml - 
+
+*******************************************************************/
+extern "C" HRESULT UserExperienceParseFromXml(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in IXMLDOMNode* pixnBundle
+    )
+{
+    HRESULT hr = S_OK;
+    IXMLDOMNode* pixnUserExperienceNode = NULL;
+
+    // select UX node
+    hr = XmlSelectSingleNode(pixnBundle, L"UX", &pixnUserExperienceNode);
+    if (S_FALSE == hr)
+    {
+        hr = E_NOTFOUND;
+    }
+    ExitOnFailure(hr, "Failed to select user experience node.");
+
+    // parse splash screen
+    hr = XmlGetYesNoAttribute(pixnUserExperienceNode, L"SplashScreen", &pUserExperience->fSplashScreen);
+    if (E_NOTFOUND != hr)
+    {
+        ExitOnFailure(hr, "Failed to to get UX/@SplashScreen");
+    }
+
+    // parse payloads
+    hr = PayloadsParseFromXml(&pUserExperience->payloads, NULL, NULL, pixnUserExperienceNode);
+    ExitOnFailure(hr, "Failed to parse user experience payloads.");
+
+    // make sure we have at least one payload
+    if (0 == pUserExperience->payloads.cPayloads)
+    {
+        hr = E_UNEXPECTED;
+        ExitOnFailure(hr, "Too few UX payloads.");
+    }
+
+LExit:
+    ReleaseObject(pixnUserExperienceNode);
+
+    return hr;
+}
+
+/*******************************************************************
+ UserExperienceUninitialize - 
+
+*******************************************************************/
+extern "C" void UserExperienceUninitialize(
+    __in BURN_USER_EXPERIENCE* pUserExperience
+    )
+{
+    ReleaseStr(pUserExperience->sczTempDirectory);
+    PayloadsUninitialize(&pUserExperience->payloads);
+
+    // clear struct
+    memset(pUserExperience, 0, sizeof(BURN_USER_EXPERIENCE));
+}
+
+/*******************************************************************
+ UserExperienceLoad - 
+
+*******************************************************************/
+extern "C" HRESULT UserExperienceLoad(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in BOOTSTRAPPER_ENGINE_CONTEXT* pEngineContext,
+    __in BOOTSTRAPPER_COMMAND* pCommand
+    )
+{
+    HRESULT hr = S_OK;
+    BOOTSTRAPPER_CREATE_ARGS args = { };
+    BOOTSTRAPPER_CREATE_RESULTS results = { };
+
+    args.cbSize = sizeof(BOOTSTRAPPER_CREATE_ARGS);
+    args.pCommand = pCommand;
+    args.pfnBootstrapperEngineProc = EngineForApplicationProc;
+    args.pvBootstrapperEngineProcContext = pEngineContext;
+    args.qwEngineAPIVersion = MAKEQWORDVERSION(0, 0, 0, 5); // TODO: need to decide whether to keep this, and if so when to update it.
+
+    results.cbSize = sizeof(BOOTSTRAPPER_CREATE_RESULTS);
+
+    // Load BA DLL.
+    pUserExperience->hUXModule = ::LoadLibraryExW(pUserExperience->payloads.rgPayloads[0].sczLocalFilePath, NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
+    ExitOnNullWithLastError(pUserExperience->hUXModule, hr, "Failed to load UX DLL.");
+
+    // Get BootstrapperApplicationCreate entry-point.
+    PFN_BOOTSTRAPPER_APPLICATION_CREATE pfnCreate = (PFN_BOOTSTRAPPER_APPLICATION_CREATE)::GetProcAddress(pUserExperience->hUXModule, "BootstrapperApplicationCreate");
+    ExitOnNullWithLastError(pfnCreate, hr, "Failed to get BootstrapperApplicationCreate entry-point");
+
+    // Create BA.
+    hr = pfnCreate(&args, &results);
+    ExitOnFailure(hr, "Failed to create BA.");
+
+    pUserExperience->pfnBAProc = results.pfnBootstrapperApplicationProc;
+    pUserExperience->pvBAProcContext = results.pvBootstrapperApplicationProcContext;
+
+LExit:
+    return hr;
+}
+
+/*******************************************************************
+ UserExperienceUnload - 
+
+*******************************************************************/
+extern "C" HRESULT UserExperienceUnload(
+    __in BURN_USER_EXPERIENCE* pUserExperience
+    )
+{
+    HRESULT hr = S_OK;
+
+    if (pUserExperience->hUXModule)
+    {
+        // Get BootstrapperApplicationDestroy entry-point and call it if it exists.
+        PFN_BOOTSTRAPPER_APPLICATION_DESTROY pfnDestroy = (PFN_BOOTSTRAPPER_APPLICATION_DESTROY)::GetProcAddress(pUserExperience->hUXModule, "BootstrapperApplicationDestroy");
+        if (pfnDestroy)
+        {
+            pfnDestroy();
+        }
+
+        // Free BA DLL.
+        if (!::FreeLibrary(pUserExperience->hUXModule))
+        {
+            hr = HRESULT_FROM_WIN32(::GetLastError());
+            TraceError(hr, "Failed to unload BA DLL.");
+        }
+        pUserExperience->hUXModule = NULL;
+    }
+
+//LExit:
+    return hr;
+}
+
+extern "C" HRESULT UserExperienceEnsureWorkingFolder(
+    __in LPCWSTR wzBundleId,
+    __deref_out_z LPWSTR* psczUserExperienceWorkingFolder
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR sczWorkingFolder = NULL;
+
+    hr = CacheEnsureWorkingFolder(wzBundleId, &sczWorkingFolder);
+    ExitOnFailure(hr, "Failed to create working folder.");
+
+    hr = StrAllocFormatted(psczUserExperienceWorkingFolder, L"%ls%ls\\", sczWorkingFolder, L".ba");
+    ExitOnFailure(hr, "Failed to calculate the bootstrapper application working path.");
+
+    hr = DirEnsureExists(*psczUserExperienceWorkingFolder, NULL);
+    ExitOnFailure(hr, "Failed create bootstrapper application working folder.");
+
+LExit:
+    ReleaseStr(sczWorkingFolder);
+
+    return hr;
+}
+
+
+extern "C" HRESULT UserExperienceRemove(
+    __in BURN_USER_EXPERIENCE* pUserExperience
+    )
+{
+    HRESULT hr = S_OK;
+
+    // Remove temporary UX directory
+    if (pUserExperience->sczTempDirectory)
+    {
+        hr = DirEnsureDeleteEx(pUserExperience->sczTempDirectory, DIR_DELETE_FILES | DIR_DELETE_RECURSE | DIR_DELETE_SCHEDULE);
+        TraceError(hr, "Could not delete bootstrapper application folder. Some files will be left in the temp folder.");
+    }
+
+//LExit:
+    return hr;
+}
+
+extern "C" int UserExperienceSendError(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in BOOTSTRAPPER_ERROR_TYPE errorType,
+    __in_z_opt LPCWSTR wzPackageId,
+    __in HRESULT hrCode,
+    __in_z_opt LPCWSTR wzError,
+    __in DWORD uiFlags,
+    __in int nRecommendation
+    )
+{
+    int nResult = nRecommendation;
+    DWORD dwCode = HRESULT_CODE(hrCode);
+    LPWSTR sczError = NULL;
+
+    // If no error string was provided, try to get the error string from the HRESULT.
+    if (!wzError)
+    {
+        if (SUCCEEDED(StrAllocFromError(&sczError, hrCode, NULL)))
+        {
+            wzError = sczError;
+        }
+    }
+
+    UserExperienceOnError(pUserExperience, errorType, wzPackageId, dwCode, wzError, uiFlags, 0, NULL, &nResult); // ignore return value.
+
+    ReleaseStr(sczError);
+    return nResult;
+}
+
+extern "C" HRESULT UserExperienceActivateEngine(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __out_opt BOOL* pfActivated
+    )
+{
+    HRESULT hr = S_OK;
+    BOOL fActivated;
+
+    ::EnterCriticalSection(&pUserExperience->csEngineActive);
+    if (InterlockedCompareExchange(reinterpret_cast<LONG*>(&pUserExperience->fEngineActive), TRUE, FALSE))
+    {
+        AssertSz(FALSE, "Engine should have been deactivated before activating it.");
+
+        fActivated = FALSE;
+        hr = HRESULT_FROM_WIN32(ERROR_INVALID_STATE);
+    }
+    else
+    {
+        fActivated = TRUE;
+    }
+    ::LeaveCriticalSection(&pUserExperience->csEngineActive);
+
+    if (pfActivated)
+    {
+        *pfActivated = fActivated;
+    }
+    ExitOnRootFailure(hr, "Engine active cannot be changed because it was already in that state.");
+
+LExit:
+    return hr;
+}
+
+extern "C" void UserExperienceDeactivateEngine(
+    __in BURN_USER_EXPERIENCE* pUserExperience
+    )
+{
+    BOOL fActive = InterlockedExchange(reinterpret_cast<LONG*>(&pUserExperience->fEngineActive), FALSE);
+    fActive = fActive; // prevents warning in "ship" build.
+    AssertSz(fActive, "Engine should have be active before deactivating it.");
+}
+
+extern "C" HRESULT UserExperienceEnsureEngineInactive(
+    __in BURN_USER_EXPERIENCE* pUserExperience
+    )
+{
+    HRESULT hr = pUserExperience->fEngineActive ? HRESULT_FROM_WIN32(ERROR_BUSY) : S_OK;
+    ExitOnRootFailure(hr, "Engine is active, cannot proceed.");
+
+LExit:
+    return hr;
+}
+
+extern "C" void UserExperienceExecuteReset(
+    __in BURN_USER_EXPERIENCE* pUserExperience
+    )
+{
+    pUserExperience->hrApplyError = S_OK;
+    pUserExperience->hwndApply = NULL;
+}
+
+extern "C" void UserExperienceExecutePhaseComplete(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in HRESULT hrResult
+    )
+{
+    if (FAILED(hrResult))
+    {
+        pUserExperience->hrApplyError = hrResult;
+    }
+}
+
+EXTERN_C BAAPI UserExperienceOnApplyBegin(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in DWORD dwPhaseCount
+    )
+{
+    HRESULT hr = S_OK;
+    BA_ONAPPLYBEGIN_ARGS args = { };
+    BA_ONAPPLYBEGIN_RESULTS results = { };
+
+    args.cbSize = sizeof(args);
+    args.dwPhaseCount = dwPhaseCount;
+
+    results.cbSize = sizeof(results);
+
+    hr = pUserExperience->pfnBAProc(BOOTSTRAPPER_APPLICATION_MESSAGE_ONAPPLYBEGIN, &args, &results, pUserExperience->pvBAProcContext);
+    ExitOnFailure(hr, "BA OnApplyBegin failed.");
+
+    if (results.fCancel)
+    {
+        hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
+    }
+
+LExit:
+    return hr;
+}
+
+EXTERN_C BAAPI UserExperienceOnApplyComplete(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in HRESULT hrStatus,
+    __in BOOTSTRAPPER_APPLY_RESTART restart,
+    __inout BOOTSTRAPPER_APPLYCOMPLETE_ACTION* pAction
+    )
+{
+    HRESULT hr = S_OK;
+    BA_ONAPPLYCOMPLETE_ARGS args = { };
+    BA_ONAPPLYCOMPLETE_RESULTS results = { };
+
+    args.cbSize = sizeof(args);
+    args.hrStatus = hrStatus;
+    args.restart = restart;
+    args.recommendation = *pAction;
+
+    results.cbSize = sizeof(results);
+    results.action = *pAction;
+
+    hr = pUserExperience->pfnBAProc(BOOTSTRAPPER_APPLICATION_MESSAGE_ONAPPLYCOMPLETE, &args, &results, pUserExperience->pvBAProcContext);
+    ExitOnFailure(hr, "BA OnApplyComplete failed.");
+
+    *pAction = results.action;
+
+LExit:
+    return hr;
+}
+
+EXTERN_C BAAPI UserExperienceOnCacheAcquireBegin(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in_z_opt LPCWSTR wzPackageOrContainerId,
+    __in_z_opt LPCWSTR wzPayloadId,
+    __in BOOTSTRAPPER_CACHE_OPERATION operation,
+    __in_z LPCWSTR wzSource
+    )
+{
+    HRESULT hr = S_OK;
+    BA_ONCACHEACQUIREBEGIN_ARGS args = { };
+    BA_ONCACHEACQUIREBEGIN_RESULTS results = { };
+
+    args.cbSize = sizeof(args);
+    args.wzPackageOrContainerId = wzPackageOrContainerId;
+    args.wzPayloadId = wzPayloadId;
+    args.operation = operation;
+    args.wzSource = wzSource;
+
+    results.cbSize = sizeof(results);
+
+    hr = pUserExperience->pfnBAProc(BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHEACQUIREBEGIN, &args, &results, pUserExperience->pvBAProcContext);
+    ExitOnFailure(hr, "BA OnCacheAcquireBegin failed.");
+
+    if (results.fCancel)
+    {
+        hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
+    }
+
+LExit:
+    return hr;
+}
+
+EXTERN_C BAAPI UserExperienceOnCacheAcquireComplete(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in_z_opt LPCWSTR wzPackageOrContainerId,
+    __in_z_opt LPCWSTR wzPayloadId,
+    __in HRESULT hrStatus,
+    __inout BOOL* pfRetry
+    )
+{
+    HRESULT hr = S_OK;
+    BA_ONCACHEACQUIRECOMPLETE_ARGS args = { };
+    BA_ONCACHEACQUIRECOMPLETE_RESULTS results = { };
+
+    args.cbSize = sizeof(args);
+    args.wzPackageOrContainerId = wzPackageOrContainerId;
+    args.wzPayloadId = wzPayloadId;
+    args.hrStatus = hrStatus;
+    args.recommendation = *pfRetry ? BOOTSTRAPPER_CACHEACQUIRECOMPLETE_ACTION_RETRY : BOOTSTRAPPER_CACHEACQUIRECOMPLETE_ACTION_NONE;
+
+    results.cbSize = sizeof(results);
+    results.action = args.recommendation;
+
+    hr = pUserExperience->pfnBAProc(BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHEACQUIRECOMPLETE, &args, &results, pUserExperience->pvBAProcContext);
+    ExitOnFailure(hr, "BA OnCacheAcquireComplete failed.");
+
+    if (FAILED(hrStatus))
+    {
+        *pfRetry = BOOTSTRAPPER_CACHEACQUIRECOMPLETE_ACTION_RETRY == results.action;
+    }
+
+LExit:
+    return hr;
+}
+
+EXTERN_C BAAPI UserExperienceOnCacheAcquireProgress(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in_z_opt LPCWSTR wzPackageOrContainerId,
+    __in_z_opt LPCWSTR wzPayloadId,
+    __in DWORD64 dw64Progress,
+    __in DWORD64 dw64Total,
+    __in DWORD dwOverallPercentage
+    )
+{
+    HRESULT hr = S_OK;
+    BA_ONCACHEACQUIREPROGRESS_ARGS args = { };
+    BA_ONCACHEACQUIREPROGRESS_RESULTS results = { };
+
+    args.cbSize = sizeof(args);
+    args.wzPackageOrContainerId = wzPackageOrContainerId;
+    args.wzPayloadId = wzPayloadId;
+    args.dw64Progress = dw64Progress;
+    args.dw64Total = dw64Total;
+    args.dwOverallPercentage = dwOverallPercentage;
+
+    results.cbSize = sizeof(results);
+
+    hr = pUserExperience->pfnBAProc(BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHEACQUIREPROGRESS, &args, &results, pUserExperience->pvBAProcContext);
+    ExitOnFailure(hr, "BA OnCacheAcquireProgress failed.");
+
+    if (results.fCancel)
+    {
+        hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
+    }
+
+LExit:
+    return hr;
+}
+
+EXTERN_C BAAPI UserExperienceOnCacheBegin(
+    __in BURN_USER_EXPERIENCE* pUserExperience
+    )
+{
+    HRESULT hr = S_OK;
+    BA_ONCACHEBEGIN_ARGS args = { };
+    BA_ONCACHEBEGIN_RESULTS results = { };
+
+    args.cbSize = sizeof(args);
+
+    results.cbSize = sizeof(results);
+
+    hr = pUserExperience->pfnBAProc(BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHEBEGIN, &args, &results, pUserExperience->pvBAProcContext);
+    ExitOnFailure(hr, "BA OnCacheBegin failed.");
+
+    if (results.fCancel)
+    {
+        hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
+    }
+
+LExit:
+    return hr;
+}
+
+EXTERN_C BAAPI UserExperienceOnCacheComplete(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in HRESULT hrStatus
+    )
+{
+    HRESULT hr = S_OK;
+    BA_ONCACHECOMPLETE_ARGS args = { };
+    BA_ONCACHECOMPLETE_RESULTS results = { };
+
+    args.cbSize = sizeof(args);
+    args.hrStatus = hrStatus;
+
+    results.cbSize = sizeof(results);
+
+    hr = pUserExperience->pfnBAProc(BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHECOMPLETE, &args, &results, pUserExperience->pvBAProcContext);
+    ExitOnFailure(hr, "BA OnCacheComplete failed.");
+
+LExit:
+    return hr;
+}
+
+EXTERN_C BAAPI UserExperienceOnCachePackageBegin(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in_z LPCWSTR wzPackageId,
+    __in DWORD cCachePayloads,
+    __in DWORD64 dw64PackageCacheSize
+    )
+{
+    HRESULT hr = S_OK;
+    BA_ONCACHEPACKAGEBEGIN_ARGS args = { };
+    BA_ONCACHEPACKAGEBEGIN_RESULTS results = { };
+
+    args.cbSize = sizeof(args);
+    args.wzPackageId = wzPackageId;
+    args.cCachePayloads = cCachePayloads;
+    args.dw64PackageCacheSize = dw64PackageCacheSize;
+
+    results.cbSize = sizeof(results);
+
+    hr = pUserExperience->pfnBAProc(BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHEPACKAGEBEGIN, &args, &results, pUserExperience->pvBAProcContext);
+    ExitOnFailure(hr, "BA OnCachePackageBegin failed.");
+
+    if (results.fCancel)
+    {
+        hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
+    }
+
+LExit:
+    return hr;
+}
+
+EXTERN_C BAAPI UserExperienceOnCachePackageComplete(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in_z LPCWSTR wzPackageId,
+    __in HRESULT hrStatus,
+    __inout BOOTSTRAPPER_CACHEPACKAGECOMPLETE_ACTION* pAction
+    )
+{
+    HRESULT hr = S_OK;
+    BA_ONCACHEPACKAGECOMPLETE_ARGS args = { };
+    BA_ONCACHEPACKAGECOMPLETE_RESULTS results = { };
+
+    args.cbSize = sizeof(args);
+    args.wzPackageId = wzPackageId;
+    args.hrStatus = hrStatus;
+    args.recommendation = *pAction;
+
+    results.cbSize = sizeof(results);
+    results.action = *pAction;
+
+    hr = pUserExperience->pfnBAProc(BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHEPACKAGECOMPLETE, &args, &results, pUserExperience->pvBAProcContext);
+    ExitOnFailure(hr, "BA OnCachePackageComplete failed.");
+
+    if (FAILED(hrStatus))
+    {
+        *pAction = results.action;
+    }
+
+LExit:
+    return hr;
+}
+
+EXTERN_C BAAPI UserExperienceOnCacheVerifyBegin(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in_z_opt LPCWSTR wzPackageOrContainerId,
+    __in_z_opt LPCWSTR wzPayloadId
+    )
+{
+    HRESULT hr = S_OK;
+    BA_ONCACHEVERIFYBEGIN_ARGS args = { };
+    BA_ONCACHEVERIFYBEGIN_RESULTS results = { };
+
+    args.cbSize = sizeof(args);
+    args.wzPackageOrContainerId = wzPackageOrContainerId;
+    args.wzPayloadId = wzPayloadId;
+
+    results.cbSize = sizeof(results);
+
+    hr = pUserExperience->pfnBAProc(BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHEVERIFYBEGIN, &args, &results, pUserExperience->pvBAProcContext);
+    ExitOnFailure(hr, "BA OnCacheVerifyBegin failed.");
+
+    if (results.fCancel)
+    {
+        hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
+    }
+
+LExit:
+    return hr;
+}
+
+EXTERN_C BAAPI UserExperienceOnCacheVerifyComplete(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in_z_opt LPCWSTR wzPackageOrContainerId,
+    __in_z_opt LPCWSTR wzPayloadId,
+    __in HRESULT hrStatus,
+    __inout BOOTSTRAPPER_CACHEVERIFYCOMPLETE_ACTION* pAction
+    )
+{
+    HRESULT hr = S_OK;
+    BA_ONCACHEVERIFYCOMPLETE_ARGS args = { };
+    BA_ONCACHEVERIFYCOMPLETE_RESULTS results = { };
+
+    args.cbSize = sizeof(args);
+    args.wzPackageOrContainerId = wzPackageOrContainerId;
+    args.wzPayloadId = wzPayloadId;
+    args.hrStatus = hrStatus;
+    args.recommendation = *pAction;
+
+    results.cbSize = sizeof(results);
+    results.action = *pAction;
+
+    hr = pUserExperience->pfnBAProc(BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHEVERIFYCOMPLETE, &args, &results, pUserExperience->pvBAProcContext);
+    ExitOnFailure(hr, "BA OnCacheVerifyComplete failed.");
+
+    if (FAILED(hrStatus))
+    {
+        *pAction = results.action;
+    }
+
+LExit:
+    return hr;
+}
+
+EXTERN_C BAAPI UserExperienceOnDetectBegin(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in BOOL fInstalled,
+    __in DWORD cPackages
+    )
+{
+    HRESULT hr = S_OK;
+    BA_ONDETECTBEGIN_ARGS args = { };
+    BA_ONDETECTBEGIN_RESULTS results = { };
+
+    args.cbSize = sizeof(args);
+    args.cPackages = cPackages;
+    args.fInstalled = fInstalled;
+
+    results.cbSize = sizeof(results);
+
+    hr = pUserExperience->pfnBAProc(BOOTSTRAPPER_APPLICATION_MESSAGE_ONDETECTBEGIN, &args, &results, pUserExperience->pvBAProcContext);
+    ExitOnFailure(hr, "BA OnDetectBegin failed.");
+
+    if (results.fCancel)
+    {
+        hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
+    }
+
+LExit:
+    return hr;
+}
+
+EXTERN_C BAAPI UserExperienceOnDetectCompatibleMsiPackage(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in_z LPCWSTR wzPackageId,
+    __in_z LPCWSTR wzCompatiblePackageId,
+    __in DWORD64 dw64CompatiblePackageVersion
+    )
+{
+    HRESULT hr = S_OK;
+    BA_ONDETECTCOMPATIBLEMSIPACKAGE_ARGS args = { };
+    BA_ONDETECTCOMPATIBLEMSIPACKAGE_RESULTS results = { };
+
+    args.cbSize = sizeof(args);
+    args.wzPackageId = wzPackageId;
+    args.wzCompatiblePackageId = wzCompatiblePackageId;
+    args.dw64CompatiblePackageVersion = dw64CompatiblePackageVersion;
+
+    results.cbSize = sizeof(results);
+
+    hr = pUserExperience->pfnBAProc(BOOTSTRAPPER_APPLICATION_MESSAGE_ONDETECTCOMPATIBLEMSIPACKAGE, &args, &results, pUserExperience->pvBAProcContext);
+    ExitOnFailure(hr, "BA OnDetectCompatibleMsiPackage failed.");
+
+    if (results.fCancel)
+    {
+        hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
+    }
+
+LExit:
+    return hr;
+}
+
+EXTERN_C BAAPI UserExperienceOnDetectComplete(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in HRESULT hrStatus
+    )
+{
+    HRESULT hr = S_OK;
+    BA_ONDETECTCOMPLETE_ARGS args = { };
+    BA_ONDETECTCOMPLETE_RESULTS results = { };
+
+    args.cbSize = sizeof(args);
+    args.hrStatus = hrStatus;
+
+    results.cbSize = sizeof(results);
+
+    hr = pUserExperience->pfnBAProc(BOOTSTRAPPER_APPLICATION_MESSAGE_ONDETECTCOMPLETE, &args, &results, pUserExperience->pvBAProcContext);
+    ExitOnFailure(hr, "BA OnDetectComplete failed.");
+
+LExit:
+    return hr;
+}
+
+EXTERN_C BAAPI UserExperienceOnDetectForwardCompatibleBundle(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in_z LPCWSTR wzBundleId,
+    __in BOOTSTRAPPER_RELATION_TYPE relationType,
+    __in_z LPCWSTR wzBundleTag,
+    __in BOOL fPerMachine,
+    __in DWORD64 dw64Version,
+    __inout BOOL* pfIgnoreBundle
+    )
+{
+    HRESULT hr = S_OK;
+    BA_ONDETECTFORWARDCOMPATIBLEBUNDLE_ARGS args = { };
+    BA_ONDETECTFORWARDCOMPATIBLEBUNDLE_RESULTS results = { };
+
+    args.cbSize = sizeof(args);
+    args.wzBundleId = wzBundleId;
+    args.relationType = relationType;
+    args.wzBundleTag = wzBundleTag;
+    args.fPerMachine = fPerMachine;
+    args.dw64Version = dw64Version;
+
+    results.cbSize = sizeof(results);
+    results.fIgnoreBundle = *pfIgnoreBundle;
+
+    hr = pUserExperience->pfnBAProc(BOOTSTRAPPER_APPLICATION_MESSAGE_ONDETECTFORWARDCOMPATIBLEBUNDLE, &args, &results, pUserExperience->pvBAProcContext);
+    ExitOnFailure(hr, "BA OnDetectForwardCompatibleBundle failed.");
+
+    if (results.fCancel)
+    {
+        hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
+    }
+    *pfIgnoreBundle = results.fIgnoreBundle;
+
+LExit:
+    return hr;
+}
+
+EXTERN_C BAAPI UserExperienceOnDetectMsiFeature(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in_z LPCWSTR wzPackageId,
+    __in_z LPCWSTR wzFeatureId,
+    __in BOOTSTRAPPER_FEATURE_STATE state
+    )
+{
+    HRESULT hr = S_OK;
+    BA_ONDETECTMSIFEATURE_ARGS args = { };
+    BA_ONDETECTMSIFEATURE_RESULTS results = { };
+
+    args.cbSize = sizeof(args);
+    args.wzPackageId = wzPackageId;
+    args.wzFeatureId = wzFeatureId;
+    args.state = state;
+
+    results.cbSize = sizeof(results);
+
+    hr = pUserExperience->pfnBAProc(BOOTSTRAPPER_APPLICATION_MESSAGE_ONDETECTMSIFEATURE, &args, &results, pUserExperience->pvBAProcContext);
+    ExitOnFailure(hr, "BA OnDetectMsiFeature failed.");
+
+    if (results.fCancel)
+    {
+        hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
+    }
+
+LExit:
+    return hr;
+}
+
+EXTERN_C BAAPI UserExperienceOnDetectPackageBegin(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in_z LPCWSTR wzPackageId
+    )
+{
+    HRESULT hr = S_OK;
+    BA_ONDETECTPACKAGEBEGIN_ARGS args = { };
+    BA_ONDETECTPACKAGEBEGIN_RESULTS results = { };
+
+    args.cbSize = sizeof(args);
+    args.wzPackageId = wzPackageId;
+
+    results.cbSize = sizeof(results);
+
+    hr = pUserExperience->pfnBAProc(BOOTSTRAPPER_APPLICATION_MESSAGE_ONDETECTPACKAGEBEGIN, &args, &results, pUserExperience->pvBAProcContext);
+    ExitOnFailure(hr, "BA OnDetectPackageBegin failed.");
+
+    if (results.fCancel)
+    {
+        hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
+    }
+
+LExit:
+    return hr;
+}
+
+EXTERN_C BAAPI UserExperienceOnDetectPackageComplete(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in_z LPCWSTR wzPackageId,
+    __in HRESULT hrStatus,
+    __in BOOTSTRAPPER_PACKAGE_STATE state
+    )
+{
+    HRESULT hr = S_OK;
+    BA_ONDETECTPACKAGECOMPLETE_ARGS args = { };
+    BA_ONDETECTPACKAGECOMPLETE_RESULTS results = { };
+
+    args.cbSize = sizeof(args);
+    args.wzPackageId = wzPackageId;
+    args.hrStatus = hrStatus;
+    args.state = state;
+
+    results.cbSize = sizeof(results);
+
+    hr = pUserExperience->pfnBAProc(BOOTSTRAPPER_APPLICATION_MESSAGE_ONDETECTPACKAGECOMPLETE, &args, &results, pUserExperience->pvBAProcContext);
+    ExitOnFailure(hr, "BA OnDetectPackageComplete failed.");
+
+LExit:
+    return hr;
+}
+
+EXTERN_C BAAPI UserExperienceOnDetectRelatedBundle(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in_z LPCWSTR wzBundleId,
+    __in BOOTSTRAPPER_RELATION_TYPE relationType,
+    __in_z LPCWSTR wzBundleTag,
+    __in BOOL fPerMachine,
+    __in DWORD64 dw64Version,
+    __in BOOTSTRAPPER_RELATED_OPERATION operation
+    )
+{
+    HRESULT hr = S_OK;
+    BA_ONDETECTRELATEDBUNDLE_ARGS args = { };
+    BA_ONDETECTRELATEDBUNDLE_RESULTS results = { };
+
+    args.cbSize = sizeof(args);
+    args.wzBundleId = wzBundleId;
+    args.relationType = relationType;
+    args.wzBundleTag = wzBundleTag;
+    args.fPerMachine = fPerMachine;
+    args.dw64Version = dw64Version;
+    args.operation = operation;
+
+    results.cbSize = sizeof(results);
+
+    hr = pUserExperience->pfnBAProc(BOOTSTRAPPER_APPLICATION_MESSAGE_ONDETECTRELATEDBUNDLE, &args, &results, pUserExperience->pvBAProcContext);
+    ExitOnFailure(hr, "BA OnDetectRelatedBundle failed.");
+
+    if (results.fCancel)
+    {
+        hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
+    }
+
+LExit:
+    return hr;
+}
+
+EXTERN_C BAAPI UserExperienceOnDetectRelatedMsiPackage(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in_z LPCWSTR wzPackageId,
+    __in_z LPCWSTR wzUpgradeCode,
+    __in_z LPCWSTR wzProductCode,
+    __in BOOL fPerMachine,
+    __in DWORD64 dw64Version,
+    __in BOOTSTRAPPER_RELATED_OPERATION operation
+    )
+{
+    HRESULT hr = S_OK;
+    BA_ONDETECTRELATEDMSIPACKAGE_ARGS args = { };
+    BA_ONDETECTRELATEDMSIPACKAGE_RESULTS results = { };
+
+    args.cbSize = sizeof(args);
+    args.wzPackageId = wzPackageId;
+    args.wzUpgradeCode = wzUpgradeCode;
+    args.wzProductCode = wzProductCode;
+    args.fPerMachine = fPerMachine;
+    args.dw64Version = dw64Version;
+    args.operation = operation;
+
+    results.cbSize = sizeof(results);
+
+    hr = pUserExperience->pfnBAProc(BOOTSTRAPPER_APPLICATION_MESSAGE_ONDETECTRELATEDMSIPACKAGE, &args, &results, pUserExperience->pvBAProcContext);
+    ExitOnFailure(hr, "BA OnDetectRelatedMsiPackage failed.");
+
+    if (results.fCancel)
+    {
+        hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
+    }
+
+LExit:
+    return hr;
+}
+
+EXTERN_C BAAPI UserExperienceOnDetectTargetMsiPackage(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in_z LPCWSTR wzPackageId,
+    __in_z LPCWSTR wzProductCode,
+    __in BOOTSTRAPPER_PACKAGE_STATE patchState
+    )
+{
+    HRESULT hr = S_OK;
+    BA_ONDETECTTARGETMSIPACKAGE_ARGS args = { };
+    BA_ONDETECTTARGETMSIPACKAGE_RESULTS results = { };
+
+    args.cbSize = sizeof(args);
+    args.wzPackageId = wzPackageId;
+    args.wzProductCode = wzProductCode;
+    args.patchState = patchState;
+
+    results.cbSize = sizeof(results);
+
+    hr = pUserExperience->pfnBAProc(BOOTSTRAPPER_APPLICATION_MESSAGE_ONDETECTTARGETMSIPACKAGE, &args, &results, pUserExperience->pvBAProcContext);
+    ExitOnFailure(hr, "BA OnDetectTargetMsiPackage failed.");
+
+    if (results.fCancel)
+    {
+        hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
+    }
+
+LExit:
+    return hr;
+}
+
+EXTERN_C BAAPI UserExperienceOnDetectUpdate(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in_z LPCWSTR wzUpdateLocation,
+    __in DWORD64 dw64Size,
+    __in DWORD64 dw64Version,
+    __in_z_opt LPCWSTR wzTitle,
+    __in_z_opt LPCWSTR wzSummary,
+    __in_z_opt LPCWSTR wzContentType,
+    __in_z_opt LPCWSTR wzContent,
+    __inout BOOL* pfStopProcessingUpdates
+    )
+{
+    HRESULT hr = S_OK;
+    BA_ONDETECTUPDATE_ARGS args = { };
+    BA_ONDETECTUPDATE_RESULTS results = { };
+
+    args.cbSize = sizeof(args);
+    args.wzUpdateLocation = wzUpdateLocation;
+    args.dw64Size = dw64Size;
+    args.dw64Version = dw64Version;
+    args.wzTitle = wzTitle;
+    args.wzSummary = wzSummary;
+    args.wzContentType = wzContentType;
+    args.wzContent = wzContent;
+
+    results.cbSize = sizeof(results);
+    results.fStopProcessingUpdates = *pfStopProcessingUpdates;
+
+    hr = pUserExperience->pfnBAProc(BOOTSTRAPPER_APPLICATION_MESSAGE_ONDETECTUPDATE, &args, &results, pUserExperience->pvBAProcContext);
+    ExitOnFailure(hr, "BA OnDetectUpdate failed.");
+
+    if (results.fCancel)
+    {
+        hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
+    }
+    *pfStopProcessingUpdates = results.fStopProcessingUpdates;
+
+LExit:
+    return hr;
+}
+
+EXTERN_C BAAPI UserExperienceOnDetectUpdateBegin(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in_z LPCWSTR wzUpdateLocation,
+    __inout BOOL* pfSkip
+    )
+{
+    HRESULT hr = S_OK;
+    BA_ONDETECTUPDATEBEGIN_ARGS args = { };
+    BA_ONDETECTUPDATEBEGIN_RESULTS results = { };
+
+    args.cbSize = sizeof(args);
+    args.wzUpdateLocation = wzUpdateLocation;
+
+    results.cbSize = sizeof(results);
+    results.fSkip = *pfSkip;
+
+    hr = pUserExperience->pfnBAProc(BOOTSTRAPPER_APPLICATION_MESSAGE_ONDETECTUPDATEBEGIN, &args, &results, pUserExperience->pvBAProcContext);
+    ExitOnFailure(hr, "BA OnDetectUpdateBegin failed.");
+
+    if (results.fCancel)
+    {
+        hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
+    }
+    *pfSkip = results.fSkip;
+
+LExit:
+    return hr;
+}
+
+EXTERN_C BAAPI UserExperienceOnDetectUpdateComplete(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in HRESULT hrStatus,
+    __inout BOOL* pfIgnoreError
+    )
+{
+    HRESULT hr = S_OK;
+    BA_ONDETECTUPDATECOMPLETE_ARGS args = { };
+    BA_ONDETECTUPDATECOMPLETE_RESULTS results = { };
+
+    args.cbSize = sizeof(args);
+    args.hrStatus = hrStatus;
+
+    results.cbSize = sizeof(results);
+    results.fIgnoreError = *pfIgnoreError;
+
+    hr = pUserExperience->pfnBAProc(BOOTSTRAPPER_APPLICATION_MESSAGE_ONDETECTUPDATECOMPLETE, &args, &results, pUserExperience->pvBAProcContext);
+    ExitOnFailure(hr, "BA OnDetectUpdateComplete failed.");
+
+    if (FAILED(hrStatus))
+    {
+        *pfIgnoreError = results.fIgnoreError;
+    }
+
+LExit:
+    return hr;
+}
+
+EXTERN_C BAAPI UserExperienceOnElevateBegin(
+    __in BURN_USER_EXPERIENCE* pUserExperience
+    )
+{
+    HRESULT hr = S_OK;
+    BA_ONELEVATEBEGIN_ARGS args = { };
+    BA_ONELEVATEBEGIN_RESULTS results = { };
+
+    args.cbSize = sizeof(args);
+
+    results.cbSize = sizeof(results);
+
+    hr = pUserExperience->pfnBAProc(BOOTSTRAPPER_APPLICATION_MESSAGE_ONELEVATEBEGIN, &args, &results, pUserExperience->pvBAProcContext);
+    ExitOnFailure(hr, "BA OnElevateBegin failed.");
+
+    if (results.fCancel)
+    {
+        hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
+    }
+
+LExit:
+    return hr;
+}
+
+EXTERN_C BAAPI UserExperienceOnElevateComplete(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in HRESULT hrStatus
+    )
+{
+    HRESULT hr = S_OK;
+    BA_ONELEVATECOMPLETE_ARGS args = { };
+    BA_ONELEVATECOMPLETE_RESULTS results = { };
+
+    args.cbSize = sizeof(args);
+    args.hrStatus = hrStatus;
+
+    results.cbSize = sizeof(results);
+
+    hr = pUserExperience->pfnBAProc(BOOTSTRAPPER_APPLICATION_MESSAGE_ONELEVATECOMPLETE, &args, &results, pUserExperience->pvBAProcContext);
+    ExitOnFailure(hr, "BA OnElevateComplete failed.");
+
+LExit:
+    return hr;
+}
+
+EXTERN_C BAAPI UserExperienceOnError(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in BOOTSTRAPPER_ERROR_TYPE errorType,
+    __in_z_opt LPCWSTR wzPackageId,
+    __in DWORD dwCode,
+    __in_z_opt LPCWSTR wzError,
+    __in DWORD dwUIHint,
+    __in DWORD cData,
+    __in_ecount_z_opt(cData) LPCWSTR* rgwzData,
+    __inout int* pnResult
+    )
+{
+    HRESULT hr = S_OK;
+    BA_ONERROR_ARGS args = { };
+    BA_ONERROR_RESULTS results = { };
+
+    args.cbSize = sizeof(args);
+    args.errorType = errorType;
+    args.wzPackageId = wzPackageId;
+    args.dwCode = dwCode;
+    args.wzError = wzError;
+    args.dwUIHint = dwUIHint;
+    args.cData = cData;
+    args.rgwzData = rgwzData;
+    args.nRecommendation = *pnResult;
+
+    results.cbSize = sizeof(results);
+    results.nResult = *pnResult;
+
+    hr = pUserExperience->pfnBAProc(BOOTSTRAPPER_APPLICATION_MESSAGE_ONERROR, &args, &results, pUserExperience->pvBAProcContext);
+    ExitOnFailure(hr, "BA OnError failed.");
+
+    *pnResult = results.nResult;
+
+LExit:
+    return hr;
+}
+
+EXTERN_C BAAPI UserExperienceOnExecuteBegin(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in DWORD cExecutingPackages
+    )
+{
+    HRESULT hr = S_OK;
+    BA_ONEXECUTEBEGIN_ARGS args = { };
+    BA_ONEXECUTEBEGIN_RESULTS results = { };
+
+    args.cbSize = sizeof(args);
+    args.cExecutingPackages = cExecutingPackages;
+
+    results.cbSize = sizeof(results);
+
+    hr = pUserExperience->pfnBAProc(BOOTSTRAPPER_APPLICATION_MESSAGE_ONEXECUTEBEGIN, &args, &results, pUserExperience->pvBAProcContext);
+    ExitOnFailure(hr, "BA OnExecuteBegin failed.");
+
+    if (results.fCancel)
+    {
+        hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
+    }
+
+LExit:
+    return hr;
+}
+
+EXTERN_C BAAPI UserExperienceOnExecuteComplete(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in HRESULT hrStatus
+    )
+{
+    HRESULT hr = S_OK;
+    BA_ONEXECUTECOMPLETE_ARGS args = { };
+    BA_ONEXECUTECOMPLETE_RESULTS results = { };
+
+    args.cbSize = sizeof(args);
+    args.hrStatus = hrStatus;
+
+    results.cbSize = sizeof(results);
+
+    hr = pUserExperience->pfnBAProc(BOOTSTRAPPER_APPLICATION_MESSAGE_ONEXECUTECOMPLETE, &args, &results, pUserExperience->pvBAProcContext);
+    ExitOnFailure(hr, "BA OnExecuteComplete failed.");
+
+LExit:
+    return hr;
+}
+
+EXTERN_C BAAPI UserExperienceOnExecuteFilesInUse(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in_z LPCWSTR wzPackageId,
+    __in DWORD cFiles,
+    __in_ecount_z_opt(cFiles) LPCWSTR* rgwzFiles,
+    __inout int* pnResult
+    )
+{
+    HRESULT hr = S_OK;
+    BA_ONEXECUTEFILESINUSE_ARGS args = { };
+    BA_ONEXECUTEFILESINUSE_RESULTS results = { };
+
+    args.cbSize = sizeof(args);
+    args.wzPackageId = wzPackageId;
+    args.cFiles = cFiles;
+    args.rgwzFiles = rgwzFiles;
+    args.nRecommendation = *pnResult;
+
+    results.cbSize = sizeof(results);
+    results.nResult = *pnResult;
+
+    hr = pUserExperience->pfnBAProc(BOOTSTRAPPER_APPLICATION_MESSAGE_ONEXECUTEFILESINUSE, &args, &results, pUserExperience->pvBAProcContext);
+    ExitOnFailure(hr, "BA OnExecuteFilesInUse failed.");
+
+    *pnResult = results.nResult;
+
+LExit:
+    return hr;
+}
+
+EXTERN_C BAAPI UserExperienceOnExecuteMsiMessage(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in_z LPCWSTR wzPackageId,
+    __in INSTALLMESSAGE messageType,
+    __in DWORD dwUIHint,
+    __in_z LPCWSTR wzMessage,
+    __in DWORD cData,
+    __in_ecount_z_opt(cData) LPCWSTR* rgwzData,
+    __inout int* pnResult
+    )
+{
+    HRESULT hr = S_OK;
+    BA_ONEXECUTEMSIMESSAGE_ARGS args = { };
+    BA_ONEXECUTEMSIMESSAGE_RESULTS results = { };
+
+    args.cbSize = sizeof(args);
+    args.wzPackageId = wzPackageId;
+    args.messageType = messageType;
+    args.dwUIHint = dwUIHint;
+    args.wzMessage = wzMessage;
+    args.cData = cData;
+    args.rgwzData = rgwzData;
+    args.nRecommendation = *pnResult;
+
+    results.cbSize = sizeof(results);
+    results.nResult = *pnResult;
+
+    hr = pUserExperience->pfnBAProc(BOOTSTRAPPER_APPLICATION_MESSAGE_ONEXECUTEMSIMESSAGE, &args, &results, pUserExperience->pvBAProcContext);
+    ExitOnFailure(hr, "BA OnExecuteMsiMessage failed.");
+
+    *pnResult = results.nResult;
+
+LExit:
+    return hr;
+}
+
+EXTERN_C BAAPI UserExperienceOnExecutePackageBegin(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in_z LPCWSTR wzPackageId,
+    __in BOOL fExecute
+    )
+{
+    HRESULT hr = S_OK;
+    BA_ONEXECUTEPACKAGEBEGIN_ARGS args = { };
+    BA_ONEXECUTEPACKAGEBEGIN_RESULTS results = { };
+
+    args.cbSize = sizeof(args);
+    args.wzPackageId = wzPackageId;
+    args.fExecute = fExecute;
+
+    results.cbSize = sizeof(results);
+
+    hr = pUserExperience->pfnBAProc(BOOTSTRAPPER_APPLICATION_MESSAGE_ONEXECUTEPACKAGEBEGIN, &args, &results, pUserExperience->pvBAProcContext);
+    ExitOnFailure(hr, "BA OnExecutePackageBegin failed.");
+
+    if (results.fCancel)
+    {
+        hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
+    }
+
+LExit:
+    return hr;
+}
+
+EXTERN_C BAAPI UserExperienceOnExecutePackageComplete(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in_z LPCWSTR wzPackageId,
+    __in HRESULT hrStatus,
+    __in BOOTSTRAPPER_APPLY_RESTART restart,
+    __inout BOOTSTRAPPER_EXECUTEPACKAGECOMPLETE_ACTION* pAction
+    )
+{
+    HRESULT hr = S_OK;
+    BA_ONEXECUTEPACKAGECOMPLETE_ARGS args = { };
+    BA_ONEXECUTEPACKAGECOMPLETE_RESULTS results = { };
+
+    args.cbSize = sizeof(args);
+    args.wzPackageId = wzPackageId;
+    args.hrStatus = hrStatus;
+    args.restart = restart;
+    args.recommendation = *pAction;
+
+    results.cbSize = sizeof(results);
+    results.action = *pAction;
+
+    hr = pUserExperience->pfnBAProc(BOOTSTRAPPER_APPLICATION_MESSAGE_ONEXECUTEPACKAGECOMPLETE, &args, &results, pUserExperience->pvBAProcContext);
+    ExitOnFailure(hr, "BA OnExecutePackageComplete failed.");
+
+    *pAction = results.action;
+
+LExit:
+    return hr;
+}
+
+EXTERN_C BAAPI UserExperienceOnExecutePatchTarget(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in_z LPCWSTR wzPackageId,
+    __in_z LPCWSTR wzTargetProductCode
+    )
+{
+    HRESULT hr = S_OK;
+    BA_ONEXECUTEPATCHTARGET_ARGS args = { };
+    BA_ONEXECUTEPATCHTARGET_RESULTS results = { };
+
+    args.cbSize = sizeof(args);
+    args.wzPackageId = wzPackageId;
+    args.wzTargetProductCode = wzTargetProductCode;
+
+    results.cbSize = sizeof(results);
+
+    hr = pUserExperience->pfnBAProc(BOOTSTRAPPER_APPLICATION_MESSAGE_ONEXECUTEPATCHTARGET, &args, &results, pUserExperience->pvBAProcContext);
+    ExitOnFailure(hr, "BA OnExecutePatchTarget failed.");
+
+    if (results.fCancel)
+    {
+        hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
+    }
+
+LExit:
+    return hr;
+}
+
+EXTERN_C BAAPI UserExperienceOnExecuteProgress(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in_z LPCWSTR wzPackageId,
+    __in DWORD dwProgressPercentage,
+    __in DWORD dwOverallPercentage,
+    __out int* pnResult
+    )
+{
+    HRESULT hr = S_OK;
+    BA_ONEXECUTEPROGRESS_ARGS args = { };
+    BA_ONEXECUTEPROGRESS_RESULTS results = { };
+
+    args.cbSize = sizeof(args);
+    args.wzPackageId = wzPackageId;
+    args.dwProgressPercentage = dwProgressPercentage;
+    args.dwOverallPercentage = dwOverallPercentage;
+
+    results.cbSize = sizeof(results);
+
+    hr = pUserExperience->pfnBAProc(BOOTSTRAPPER_APPLICATION_MESSAGE_ONEXECUTEPROGRESS, &args, &results, pUserExperience->pvBAProcContext);
+    ExitOnFailure(hr, "BA OnExecuteProgress failed.");
+
+LExit:
+    if (FAILED(hr))
+    {
+        *pnResult = IDERROR;
+    }
+    else if (results.fCancel)
+    {
+        *pnResult = IDCANCEL;
+    }
+    else
+    {
+        *pnResult = IDNOACTION;
+    }
+    return hr;
+}
+
+EXTERN_C BAAPI UserExperienceOnLaunchApprovedExeBegin(
+    __in BURN_USER_EXPERIENCE* pUserExperience
+    )
+{
+    HRESULT hr = S_OK;
+    BA_ONLAUNCHAPPROVEDEXEBEGIN_ARGS args = { };
+    BA_ONLAUNCHAPPROVEDEXEBEGIN_RESULTS results = { };
+
+    args.cbSize = sizeof(args);
+
+    results.cbSize = sizeof(results);
+
+    hr = pUserExperience->pfnBAProc(BOOTSTRAPPER_APPLICATION_MESSAGE_ONLAUNCHAPPROVEDEXEBEGIN, &args, &results, pUserExperience->pvBAProcContext);
+    ExitOnFailure(hr, "BA OnLaunchApprovedExeBegin failed.");
+
+    if (results.fCancel)
+    {
+        hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
+    }
+
+LExit:
+    return hr;
+}
+
+EXTERN_C BAAPI UserExperienceOnLaunchApprovedExeComplete(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in HRESULT hrStatus,
+    __in DWORD dwProcessId
+    )
+{
+    HRESULT hr = S_OK;
+    BA_ONLAUNCHAPPROVEDEXECOMPLETE_ARGS args = { };
+    BA_ONLAUNCHAPPROVEDEXECOMPLETE_RESULTS results = { };
+
+    args.cbSize = sizeof(args);
+    args.hrStatus = hrStatus;
+    args.dwProcessId = dwProcessId;
+
+    results.cbSize = sizeof(results);
+
+    hr = pUserExperience->pfnBAProc(BOOTSTRAPPER_APPLICATION_MESSAGE_ONLAUNCHAPPROVEDEXECOMPLETE, &args, &results, pUserExperience->pvBAProcContext);
+    ExitOnFailure(hr, "BA OnLaunchApprovedExeComplete failed.");
+
+LExit:
+    return hr;
+}
+
+EXTERN_C BAAPI UserExperienceOnPlanBegin(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in DWORD cPackages
+    )
+{
+    HRESULT hr = S_OK;
+    BA_ONPLANBEGIN_ARGS args = { };
+    BA_ONPLANBEGIN_RESULTS results = { };
+
+    args.cbSize = sizeof(args);
+    args.cPackages = cPackages;
+
+    results.cbSize = sizeof(results);
+
+    hr = pUserExperience->pfnBAProc(BOOTSTRAPPER_APPLICATION_MESSAGE_ONPLANBEGIN, &args, &results, pUserExperience->pvBAProcContext);
+    ExitOnFailure(hr, "BA OnPlanBegin failed.");
+
+    if (results.fCancel)
+    {
+        hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
+    }
+
+LExit:
+    return hr;
+}
+
+EXTERN_C BAAPI UserExperienceOnPlanCompatibleMsiPackageBegin(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in_z LPCWSTR wzPackageId,
+    __in_z LPCWSTR wzCompatiblePackageId,
+    __in DWORD64 dw64CompatiblePackageVersion,
+    __inout BOOTSTRAPPER_REQUEST_STATE* pRequestedState
+    )
+{
+    HRESULT hr = S_OK;
+    BA_ONPLANCOMPATIBLEMSIPACKAGEBEGIN_ARGS args = { };
+    BA_ONPLANCOMPATIBLEMSIPACKAGEBEGIN_RESULTS results = { };
+
+    args.cbSize = sizeof(args);
+    args.wzPackageId = wzPackageId;
+    args.wzCompatiblePackageId = wzCompatiblePackageId;
+    args.dw64CompatiblePackageVersion = dw64CompatiblePackageVersion;
+    args.recommendedState = *pRequestedState;
+
+    results.cbSize = sizeof(results);
+    results.requestedState = *pRequestedState;
+
+    hr = pUserExperience->pfnBAProc(BOOTSTRAPPER_APPLICATION_MESSAGE_ONPLANCOMPATIBLEMSIPACKAGEBEGIN, &args, &results, pUserExperience->pvBAProcContext);
+    ExitOnFailure(hr, "BA OnPlanCompatibleMsiPackageBegin failed.");
+
+    if (results.fCancel)
+    {
+        hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
+    }
+    *pRequestedState = results.requestedState;
+
+LExit:
+    return hr;
+}
+
+EXTERN_C BAAPI UserExperienceOnPlanCompatibleMsiPackageComplete(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in_z LPCWSTR wzPackageId,
+    __in_z LPCWSTR wzCompatiblePackageId,
+    __in HRESULT hrStatus,
+    __in BOOTSTRAPPER_PACKAGE_STATE state,
+    __in BOOTSTRAPPER_REQUEST_STATE requested,
+    __in BOOTSTRAPPER_ACTION_STATE execute,
+    __in BOOTSTRAPPER_ACTION_STATE rollback
+    )
+{
+    HRESULT hr = S_OK;
+    BA_ONPLANCOMPATIBLEMSIPACKAGECOMPLETE_ARGS args = { };
+    BA_ONPLANCOMPATIBLEMSIPACKAGECOMPLETE_RESULTS results = { };
+
+    args.cbSize = sizeof(args);
+    args.wzPackageId = wzPackageId;
+    args.wzCompatiblePackageId = wzCompatiblePackageId;
+    args.hrStatus = hrStatus;
+    args.state = state;
+    args.requested = requested;
+    args.execute = execute;
+    args.rollback = rollback;
+
+    results.cbSize = sizeof(results);
+
+    hr = pUserExperience->pfnBAProc(BOOTSTRAPPER_APPLICATION_MESSAGE_ONPLANCOMPATIBLEMSIPACKAGECOMPLETE, &args, &results, pUserExperience->pvBAProcContext);
+    ExitOnFailure(hr, "BA OnPlanCompatibleMsiPackageComplete failed.");
+
+LExit:
+    return hr;
+}
+
+EXTERN_C BAAPI UserExperienceOnPlanMsiFeature(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in_z LPCWSTR wzPackageId,
+    __in_z LPCWSTR wzFeatureId,
+    __inout BOOTSTRAPPER_FEATURE_STATE* pRequestedState
+    )
+{
+    HRESULT hr = S_OK;
+    BA_ONPLANMSIFEATURE_ARGS args = { };
+    BA_ONPLANMSIFEATURE_RESULTS results = { };
+
+    args.cbSize = sizeof(args);
+    args.wzPackageId = wzPackageId;
+    args.wzFeatureId = wzFeatureId;
+    args.recommendedState = *pRequestedState;
+
+    results.cbSize = sizeof(results);
+    results.requestedState = *pRequestedState;
+
+    hr = pUserExperience->pfnBAProc(BOOTSTRAPPER_APPLICATION_MESSAGE_ONPLANMSIFEATURE, &args, &results, pUserExperience->pvBAProcContext);
+    ExitOnFailure(hr, "BA OnPlanMsiFeature failed.");
+
+    if (results.fCancel)
+    {
+        hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
+    }
+    *pRequestedState = results.requestedState;
+
+LExit:
+    return hr;
+}
+
+EXTERN_C BAAPI UserExperienceOnPlanComplete(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in HRESULT hrStatus
+    )
+{
+    HRESULT hr = S_OK;
+    BA_ONPLANCOMPLETE_ARGS args = { };
+    BA_ONPLANCOMPLETE_RESULTS results = { };
+
+    args.cbSize = sizeof(args);
+    args.hrStatus = hrStatus;
+
+    results.cbSize = sizeof(results);
+
+    hr = pUserExperience->pfnBAProc(BOOTSTRAPPER_APPLICATION_MESSAGE_ONPLANCOMPLETE, &args, &results, pUserExperience->pvBAProcContext);
+    ExitOnFailure(hr, "BA OnPlanComplete failed.");
+
+LExit:
+    return hr;
+}
+
+EXTERN_C BAAPI UserExperienceOnPlanPackageBegin(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in_z LPCWSTR wzPackageId,
+    __inout BOOTSTRAPPER_REQUEST_STATE* pRequestedState
+    )
+{
+    HRESULT hr = S_OK;
+    BA_ONPLANPACKAGEBEGIN_ARGS args = { };
+    BA_ONPLANPACKAGEBEGIN_RESULTS results = { };
+
+    args.cbSize = sizeof(args);
+    args.wzPackageId = wzPackageId;
+    args.recommendedState = *pRequestedState;
+
+    results.cbSize = sizeof(results);
+    results.requestedState = *pRequestedState;
+
+    hr = pUserExperience->pfnBAProc(BOOTSTRAPPER_APPLICATION_MESSAGE_ONPLANPACKAGEBEGIN, &args, &results, pUserExperience->pvBAProcContext);
+    ExitOnFailure(hr, "BA OnPlanPackageBegin failed.");
+
+    if (results.fCancel)
+    {
+        hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
+    }
+    *pRequestedState = results.requestedState;
+
+LExit:
+    return hr;
+}
+
+EXTERN_C BAAPI UserExperienceOnPlanPackageComplete(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in_z LPCWSTR wzPackageId,
+    __in HRESULT hrStatus,
+    __in BOOTSTRAPPER_PACKAGE_STATE state,
+    __in BOOTSTRAPPER_REQUEST_STATE requested,
+    __in BOOTSTRAPPER_ACTION_STATE execute,
+    __in BOOTSTRAPPER_ACTION_STATE rollback
+    )
+{
+    HRESULT hr = S_OK;
+    BA_ONPLANPACKAGECOMPLETE_ARGS args = { };
+    BA_ONPLANPACKAGECOMPLETE_RESULTS results = { };
+
+    args.cbSize = sizeof(args);
+    args.wzPackageId = wzPackageId;
+    args.hrStatus = hrStatus;
+    args.state = state;
+    args.requested = requested;
+    args.execute = execute;
+    args.rollback = rollback;
+
+    results.cbSize = sizeof(results);
+
+    hr = pUserExperience->pfnBAProc(BOOTSTRAPPER_APPLICATION_MESSAGE_ONPLANPACKAGECOMPLETE, &args, &results, pUserExperience->pvBAProcContext);
+    ExitOnFailure(hr, "BA OnPlanPackageComplete failed.");
+
+LExit:
+    return hr;
+}
+
+EXTERN_C BAAPI UserExperienceOnPlanRelatedBundle(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in_z LPCWSTR wzBundleId,
+    __inout BOOTSTRAPPER_REQUEST_STATE* pRequestedState
+    )
+{
+    HRESULT hr = S_OK;
+    BA_ONPLANRELATEDBUNDLE_ARGS args = { };
+    BA_ONPLANRELATEDBUNDLE_RESULTS results = { };
+
+    args.cbSize = sizeof(args);
+    args.wzBundleId = wzBundleId;
+    args.recommendedState = *pRequestedState;
+
+    results.cbSize = sizeof(results);
+    results.requestedState = *pRequestedState;
+
+    hr = pUserExperience->pfnBAProc(BOOTSTRAPPER_APPLICATION_MESSAGE_ONPLANRELATEDBUNDLE, &args, &results, pUserExperience->pvBAProcContext);
+    ExitOnFailure(hr, "BA OnPlanRelatedBundle failed.");
+
+    if (results.fCancel)
+    {
+        hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
+    }
+    *pRequestedState = results.requestedState;
+
+LExit:
+    return hr;
+}
+
+EXTERN_C BAAPI UserExperienceOnPlanTargetMsiPackage(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in_z LPCWSTR wzPackageId,
+    __in_z LPCWSTR wzProductCode,
+    __inout BOOTSTRAPPER_REQUEST_STATE* pRequestedState
+    )
+{
+    HRESULT hr = S_OK;
+    BA_ONPLANTARGETMSIPACKAGE_ARGS args = { };
+    BA_ONPLANTARGETMSIPACKAGE_RESULTS results = { };
+
+    args.cbSize = sizeof(args);
+    args.wzPackageId = wzPackageId;
+    args.wzProductCode = wzProductCode;
+    args.recommendedState = *pRequestedState;
+
+    results.cbSize = sizeof(results);
+    results.requestedState = *pRequestedState;
+
+    hr = pUserExperience->pfnBAProc(BOOTSTRAPPER_APPLICATION_MESSAGE_ONPLANTARGETMSIPACKAGE, &args, &results, pUserExperience->pvBAProcContext);
+    ExitOnFailure(hr, "BA OnPlanTargetMsiPackage failed.");
+
+    if (results.fCancel)
+    {
+        hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
+    }
+    *pRequestedState = results.requestedState;
+
+LExit:
+    return hr;
+}
+
+EXTERN_C BAAPI UserExperienceOnProgress(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in BOOL fRollback,
+    __in DWORD dwProgressPercentage,
+    __in DWORD dwOverallPercentage
+    )
+{
+    HRESULT hr = S_OK;
+    BA_ONPROGRESS_ARGS args = { };
+    BA_ONPROGRESS_RESULTS results = { };
+
+    args.cbSize = sizeof(args);
+    args.dwProgressPercentage = dwProgressPercentage;
+    args.dwOverallPercentage = dwOverallPercentage;
+
+    results.cbSize = sizeof(results);
+
+    hr = pUserExperience->pfnBAProc(BOOTSTRAPPER_APPLICATION_MESSAGE_ONPROGRESS, &args, &results, pUserExperience->pvBAProcContext);
+    hr = FilterExecuteResult(pUserExperience, hr, fRollback, results.fCancel, L"OnProgress");
+
+    return hr;
+}
+
+EXTERN_C BAAPI UserExperienceOnRegisterBegin(
+    __in BURN_USER_EXPERIENCE* pUserExperience
+    )
+{
+    HRESULT hr = S_OK;
+    BA_ONREGISTERBEGIN_ARGS args = { };
+    BA_ONREGISTERBEGIN_RESULTS results = { };
+
+    args.cbSize = sizeof(args);
+
+    results.cbSize = sizeof(results);
+
+    hr = pUserExperience->pfnBAProc(BOOTSTRAPPER_APPLICATION_MESSAGE_ONREGISTERBEGIN, &args, &results, pUserExperience->pvBAProcContext);
+    ExitOnFailure(hr, "BA OnRegisterBegin failed.");
+
+    if (results.fCancel)
+    {
+        hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
+    }
+
+LExit:
+    return hr;
+}
+
+EXTERN_C BAAPI UserExperienceOnRegisterComplete(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in HRESULT hrStatus
+    )
+{
+    HRESULT hr = S_OK;
+    BA_ONREGISTERCOMPLETE_ARGS args = { };
+    BA_ONREGISTERCOMPLETE_RESULTS results = { };
+
+    args.cbSize = sizeof(args);
+    args.hrStatus = hrStatus;
+
+    results.cbSize = sizeof(results);
+
+    hr = pUserExperience->pfnBAProc(BOOTSTRAPPER_APPLICATION_MESSAGE_ONREGISTERCOMPLETE, &args, &results, pUserExperience->pvBAProcContext);
+    ExitOnFailure(hr, "BA OnRegisterComplete failed.");
+
+LExit:
+    return hr;
+}
+
+EXTERN_C BAAPI UserExperienceOnResolveSource(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in_z LPCWSTR wzPackageOrContainerId,
+    __in_z_opt LPCWSTR wzPayloadId,
+    __in_z LPCWSTR wzLocalSource,
+    __in_z_opt LPCWSTR wzDownloadSource,
+    __inout BOOTSTRAPPER_RESOLVESOURCE_ACTION* pAction
+    )
+{
+    HRESULT hr = S_OK;
+    BA_ONRESOLVESOURCE_ARGS args = { };
+    BA_ONRESOLVESOURCE_RESULTS results = { };
+
+    args.cbSize = sizeof(args);
+    args.wzPackageOrContainerId = wzPackageOrContainerId;
+    args.wzPayloadId = wzPayloadId;
+    args.wzLocalSource = wzLocalSource;
+    args.wzDownloadSource = wzDownloadSource;
+    args.recommendation = *pAction;
+
+    results.cbSize = sizeof(results);
+    results.action = *pAction;
+
+    hr = pUserExperience->pfnBAProc(BOOTSTRAPPER_APPLICATION_MESSAGE_ONRESOLVESOURCE, &args, &results, pUserExperience->pvBAProcContext);
+    ExitOnFailure(hr, "BA OnResolveSource failed.");
+
+    if (results.fCancel)
+    {
+        hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
+    }
+    else
+    {
+        *pAction = results.action;
+    }
+
+LExit:
+    return hr;
+}
+
+EXTERN_C BAAPI UserExperienceOnShutdown(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __inout BOOTSTRAPPER_SHUTDOWN_ACTION* pAction
+    )
+{
+    HRESULT hr = S_OK;
+    BA_ONSHUTDOWN_ARGS args = { };
+    BA_ONSHUTDOWN_RESULTS results = { };
+
+    args.cbSize = sizeof(args);
+
+    results.cbSize = sizeof(results);
+    results.action = *pAction;
+
+    hr = pUserExperience->pfnBAProc(BOOTSTRAPPER_APPLICATION_MESSAGE_ONSHUTDOWN, &args, &results, pUserExperience->pvBAProcContext);
+    ExitOnFailure(hr, "BA OnShutdown failed.");
+
+    *pAction = results.action;
+
+LExit:
+    return hr;
+}
+
+EXTERN_C BAAPI UserExperienceOnStartup(
+    __in BURN_USER_EXPERIENCE* pUserExperience
+    )
+{
+    HRESULT hr = S_OK;
+    BA_ONSTARTUP_ARGS args = { };
+    BA_ONSTARTUP_RESULTS results = { };
+
+    args.cbSize = sizeof(args);
+
+    results.cbSize = sizeof(results);
+
+    hr = pUserExperience->pfnBAProc(BOOTSTRAPPER_APPLICATION_MESSAGE_ONSTARTUP, &args, &results, pUserExperience->pvBAProcContext);
+    ExitOnFailure(hr, "BA OnStartup failed.");
+
+LExit:
+    return hr;
+}
+
+EXTERN_C BAAPI UserExperienceOnSystemShutdown(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in DWORD dwEndSession,
+    __inout BOOL* pfCancel
+    )
+{
+    HRESULT hr = S_OK;
+    BA_ONSYSTEMSHUTDOWN_ARGS args = { };
+    BA_ONSYSTEMSHUTDOWN_RESULTS results = { };
+
+    args.cbSize = sizeof(args);
+    args.dwEndSession = dwEndSession;
+
+    results.cbSize = sizeof(results);
+    results.fCancel = *pfCancel;
+
+    hr = pUserExperience->pfnBAProc(BOOTSTRAPPER_APPLICATION_MESSAGE_ONSYSTEMSHUTDOWN, &args, &results, pUserExperience->pvBAProcContext);
+    ExitOnFailure(hr, "BA OnSystemShutdown failed.");
+    
+    *pfCancel = results.fCancel;
+
+LExit:
+    return hr;
+}
+
+EXTERN_C BAAPI UserExperienceOnUnregisterBegin(
+    __in BURN_USER_EXPERIENCE* pUserExperience
+    )
+{
+    HRESULT hr = S_OK;
+    BA_ONUNREGISTERBEGIN_ARGS args = { };
+    BA_ONUNREGISTERBEGIN_RESULTS results = { };
+
+    args.cbSize = sizeof(args);
+
+    results.cbSize = sizeof(results);
+
+    hr = pUserExperience->pfnBAProc(BOOTSTRAPPER_APPLICATION_MESSAGE_ONUNREGISTERBEGIN, &args, &results, pUserExperience->pvBAProcContext);
+    ExitOnFailure(hr, "BA OnUnregisterBegin failed.");
+
+    if (results.fCancel)
+    {
+        hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
+    }
+
+LExit:
+    return hr;
+}
+
+EXTERN_C BAAPI UserExperienceOnUnregisterComplete(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in HRESULT hrStatus
+    )
+{
+    HRESULT hr = S_OK;
+    BA_ONUNREGISTERCOMPLETE_ARGS args = { };
+    BA_ONUNREGISTERCOMPLETE_RESULTS results = { };
+
+    args.cbSize = sizeof(args);
+    args.hrStatus = hrStatus;
+
+    results.cbSize = sizeof(results);
+
+    hr = pUserExperience->pfnBAProc(BOOTSTRAPPER_APPLICATION_MESSAGE_ONUNREGISTERCOMPLETE, &args, &results, pUserExperience->pvBAProcContext);
+    ExitOnFailure(hr, "BA OnUnregisterComplete failed.");
+
+LExit:
+    return hr;
+}
+
+extern "C" int UserExperienceCheckExecuteResult(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in BOOL fRollback,
+    __in DWORD dwAllowedResults,
+    __in int nResult
+    )
+{
+    // Do not allow canceling while rolling back.
+    if (fRollback && (IDCANCEL == nResult || IDABORT == nResult))
+    {
+        nResult = IDNOACTION;
+    }
+    else if (FAILED(pUserExperience->hrApplyError) && !fRollback) // if we failed cancel except not during rollback.
+    {
+        nResult = IDCANCEL;
+    }
+
+    nResult = FilterResult(dwAllowedResults, nResult);
+    return nResult;
+}
+
+extern "C" HRESULT UserExperienceInterpretResult(
+    __in BURN_USER_EXPERIENCE* /*pUserExperience*/,
+    __in DWORD dwAllowedResults,
+    __in int nResult
+    )
+{
+    int nFilteredResult = FilterResult(dwAllowedResults, nResult);
+    return IDOK == nFilteredResult || IDNOACTION == nFilteredResult ? S_OK : IDCANCEL == nFilteredResult || IDABORT == nFilteredResult ? HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT) : HRESULT_FROM_WIN32(ERROR_INSTALL_FAILURE);
+}
+
+extern "C" HRESULT UserExperienceInterpretExecuteResult(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in BOOL fRollback,
+    __in DWORD dwAllowedResults,
+    __in int nResult
+    )
+{
+    HRESULT hr = S_OK;
+
+    // If we failed return that error unless this is rollback which should roll on.
+    if (FAILED(pUserExperience->hrApplyError) && !fRollback)
+    {
+        hr = pUserExperience->hrApplyError;
+    }
+    else
+    {
+        int nCheckedResult = UserExperienceCheckExecuteResult(pUserExperience, fRollback, dwAllowedResults, nResult);
+        hr = IDOK == nCheckedResult || IDNOACTION == nCheckedResult ? S_OK : IDCANCEL == nCheckedResult || IDABORT == nCheckedResult ? HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT) : HRESULT_FROM_WIN32(ERROR_INSTALL_FAILURE);
+    }
+
+    return hr;
+}
+
+
+// internal functions
+
+static int FilterResult(
+    __in DWORD dwAllowedResults,
+    __in int nResult
+    )
+{
+    if (IDNOACTION == nResult || IDERROR == nResult) // do nothing and errors pass through.
+    {
+    }
+    else
+    {
+        switch (dwAllowedResults)
+        {
+        case MB_OK:
+            nResult = IDOK;
+            break;
+
+        case MB_OKCANCEL:
+            if (IDOK == nResult || IDYES == nResult)
+            {
+                nResult = IDOK;
+            }
+            else if (IDCANCEL == nResult || IDABORT == nResult || IDNO == nResult)
+            {
+                nResult = IDCANCEL;
+            }
+            else
+            {
+                nResult = IDNOACTION;
+            }
+            break;
+
+        case MB_ABORTRETRYIGNORE:
+            if (IDCANCEL == nResult || IDABORT == nResult)
+            {
+                nResult = IDABORT;
+            }
+            else if (IDRETRY == nResult || IDTRYAGAIN == nResult)
+            {
+                nResult = IDRETRY;
+            }
+            else if (IDIGNORE == nResult)
+            {
+                nResult = IDIGNORE;
+            }
+            else
+            {
+                nResult = IDNOACTION;
+            }
+            break;
+
+        case MB_YESNO:
+            if (IDOK == nResult || IDYES == nResult)
+            {
+                nResult = IDYES;
+            }
+            else if (IDCANCEL == nResult || IDABORT == nResult || IDNO == nResult)
+            {
+                nResult = IDNO;
+            }
+            else
+            {
+                nResult = IDNOACTION;
+            }
+            break;
+
+        case MB_YESNOCANCEL:
+            if (IDOK == nResult || IDYES == nResult)
+            {
+                nResult = IDYES;
+            }
+            else if (IDNO == nResult)
+            {
+                nResult = IDNO;
+            }
+            else if (IDCANCEL == nResult || IDABORT == nResult)
+            {
+                nResult = IDCANCEL;
+            }
+            else
+            {
+                nResult = IDNOACTION;
+            }
+            break;
+
+        case MB_RETRYCANCEL:
+            if (IDRETRY == nResult || IDTRYAGAIN == nResult)
+            {
+                nResult = IDRETRY;
+            }
+            else if (IDCANCEL == nResult || IDABORT == nResult)
+            {
+                nResult = IDABORT;
+            }
+            else
+            {
+                nResult = IDNOACTION;
+            }
+            break;
+
+        case MB_CANCELTRYCONTINUE:
+            if (IDCANCEL == nResult || IDABORT == nResult)
+            {
+                nResult = IDABORT;
+            }
+            else if (IDRETRY == nResult || IDTRYAGAIN == nResult)
+            {
+                nResult = IDRETRY;
+            }
+            else if (IDCONTINUE == nResult || IDIGNORE == nResult)
+            {
+                nResult = IDCONTINUE;
+            }
+            else
+            {
+                nResult = IDNOACTION;
+            }
+            break;
+
+        case WIU_MB_OKIGNORECANCELRETRY: // custom Windows Installer utility return code.
+            if (IDOK == nResult || IDYES == nResult)
+            {
+                nResult = IDOK;
+            }
+            else if (IDCONTINUE == nResult || IDIGNORE == nResult)
+            {
+                nResult = IDIGNORE;
+            }
+            else if (IDCANCEL == nResult || IDABORT == nResult)
+            {
+                nResult = IDCANCEL;
+            }
+            else if (IDRETRY == nResult || IDTRYAGAIN == nResult || IDNO == nResult)
+            {
+                nResult = IDRETRY;
+            }
+            else
+            {
+                nResult = IDNOACTION;
+            }
+            break;
+
+        case MB_RETRYTRYAGAIN: // custom return code.
+            if (IDRETRY != nResult && IDTRYAGAIN != nResult)
+            {
+                nResult = IDNOACTION;
+            }
+            break;
+
+        default:
+            AssertSz(FALSE, "Unknown allowed results.");
+            break;
+        }
+    }
+
+    return nResult;
+}
+
+// This filters the BA's responses to events during apply.
+// If an apply thread failed, then return its error so this thread will bail out.
+// During rollback, the BA can't cancel.
+static HRESULT FilterExecuteResult(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in HRESULT hrStatus,
+    __in BOOL fRollback,
+    __in BOOL fCancel,
+    __in LPCWSTR sczEventName
+    )
+{
+    HRESULT hr = hrStatus;
+    HRESULT hrApplyError = pUserExperience->hrApplyError; // make sure to use the same value for the whole method, since it can be changed in other threads.
+
+    // If we failed return that error unless this is rollback which should roll on.
+    if (FAILED(hrApplyError) && !fRollback)
+    {
+        hr = hrApplyError;
+    }
+    else if (fRollback)
+    {
+        if (fCancel)
+        {
+            LogId(REPORT_STANDARD, MSG_APPLY_CANCEL_IGNORED_DURING_ROLLBACK, sczEventName);
+        }
+        // TODO: since cancel isn't allowed, should the BA's HRESULT be ignored as well?
+        // In the previous code, they could still alter rollback by returning IDERROR.
+    }
+    else
+    {
+        ExitOnFailure(hr, "BA %ls failed.", sczEventName);
+
+        if (fCancel)
+        {
+            hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
+        }
+    }
+
+LExit:
+    return hr;
+}
diff --git a/src/engine/userexperience.h b/src/engine/userexperience.h
new file mode 100644
index 00000000..27a94115
--- /dev/null
+++ b/src/engine/userexperience.h
@@ -0,0 +1,439 @@
+#pragma once
+// 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.
+
+#define BAAPI HRESULT __stdcall
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+
+// constants
+
+const DWORD MB_RETRYTRYAGAIN = 0xF;
+
+
+// structs
+
+struct BOOTSTRAPPER_ENGINE_CONTEXT;
+
+typedef struct _BURN_USER_EXPERIENCE
+{
+    BOOL fSplashScreen;
+    BURN_PAYLOADS payloads;
+
+    HMODULE hUXModule;
+    PFN_BOOTSTRAPPER_APPLICATION_PROC pfnBAProc;
+    LPVOID pvBAProcContext;
+    LPWSTR sczTempDirectory;
+
+    CRITICAL_SECTION csEngineActive;    // Changing the engine active state in the user experience must be
+                                        // syncronized through this critical section.
+                                        // Note: The engine must never do a UX callback while in this critical section.
+
+    BOOL fEngineActive;                 // Indicates that the engine is currently active with one of the execution
+                                        // steps (detect, plan, apply), and cannot accept requests from the UX.
+                                        // This flag should be cleared by the engine prior to UX callbacks that
+                                        // allows altering of the engine state.
+
+    HRESULT hrApplyError;               // Tracks is an error occurs during apply that requires the cache or
+                                        // execute threads to bail.
+
+    HWND hwndApply;                     // The window handle provided at the beginning of Apply(). Only valid
+                                        // during apply.
+
+    HWND hwndDetect;                    // The window handle provided at the beginning of Detect(). Only valid
+                                        // during Detect.
+
+    DWORD dwExitCode;                   // Exit code returned by the user experience for the engine overall.
+} BURN_USER_EXPERIENCE;
+
+// functions
+
+HRESULT UserExperienceParseFromXml(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in IXMLDOMNode* pixnBundle
+    );
+void UserExperienceUninitialize(
+    __in BURN_USER_EXPERIENCE* pUserExperience
+    );
+HRESULT UserExperienceLoad(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in BOOTSTRAPPER_ENGINE_CONTEXT* pEngineContext,
+    __in BOOTSTRAPPER_COMMAND* pCommand
+    );
+HRESULT UserExperienceUnload(
+    __in BURN_USER_EXPERIENCE* pUserExperience
+    );
+HRESULT UserExperienceEnsureWorkingFolder(
+    __in LPCWSTR wzBundleId,
+    __deref_out_z LPWSTR* psczUserExperienceWorkingFolder
+    );
+HRESULT UserExperienceRemove(
+    __in BURN_USER_EXPERIENCE* pUserExperience
+    );
+int UserExperienceSendError(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in BOOTSTRAPPER_ERROR_TYPE errorType,
+    __in_z_opt LPCWSTR wzPackageId,
+    __in HRESULT hrCode,
+    __in_z_opt LPCWSTR wzError,
+    __in DWORD uiFlags,
+    __in int nRecommendation
+    );
+HRESULT UserExperienceActivateEngine(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __out_opt BOOL* pfActivated
+    );
+void UserExperienceDeactivateEngine(
+    __in BURN_USER_EXPERIENCE* pUserExperience
+    );
+HRESULT UserExperienceEnsureEngineInactive(
+    __in BURN_USER_EXPERIENCE* pUserExperience
+    );
+void UserExperienceExecuteReset(
+    __in BURN_USER_EXPERIENCE* pUserExperience
+    );
+void UserExperienceExecutePhaseComplete(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in HRESULT hrResult
+    );
+BAAPI UserExperienceOnApplyBegin(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in DWORD dwPhaseCount
+    );
+BAAPI UserExperienceOnApplyComplete(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in HRESULT hrStatus,
+    __in BOOTSTRAPPER_APPLY_RESTART restart,
+    __inout BOOTSTRAPPER_APPLYCOMPLETE_ACTION* pAction
+);
+BAAPI UserExperienceOnCacheAcquireBegin(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in_z_opt LPCWSTR wzPackageOrContainerId,
+    __in_z_opt LPCWSTR wzPayloadId,
+    __in BOOTSTRAPPER_CACHE_OPERATION operation,
+    __in_z LPCWSTR wzSource
+    );
+BAAPI UserExperienceOnCacheAcquireComplete(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in_z_opt LPCWSTR wzPackageOrContainerId,
+    __in_z_opt LPCWSTR wzPayloadId,
+    __in HRESULT hrStatus,
+    __inout BOOL* pfRetry
+    );
+BAAPI UserExperienceOnCacheAcquireProgress(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in_z_opt LPCWSTR wzPackageOrContainerId,
+    __in_z_opt LPCWSTR wzPayloadId,
+    __in DWORD64 dw64Progress,
+    __in DWORD64 dw64Total,
+    __in DWORD dwOverallPercentage
+    );
+BAAPI UserExperienceOnCacheBegin(
+    __in BURN_USER_EXPERIENCE* pUserExperience
+    );
+BAAPI UserExperienceOnCacheComplete(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in HRESULT hrStatus
+    );
+BAAPI UserExperienceOnCachePackageBegin(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in_z LPCWSTR wzPackageId,
+    __in DWORD cCachePayloads,
+    __in DWORD64 dw64PackageCacheSize
+    );
+BAAPI UserExperienceOnCachePackageComplete(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in_z LPCWSTR wzPackageId,
+    __in HRESULT hrStatus,
+    __inout BOOTSTRAPPER_CACHEPACKAGECOMPLETE_ACTION* pAction
+    );
+BAAPI UserExperienceOnCacheVerifyBegin(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in_z_opt LPCWSTR wzPackageOrContainerId,
+    __in_z_opt LPCWSTR wzPayloadId
+    );
+BAAPI UserExperienceOnCacheVerifyComplete(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in_z_opt LPCWSTR wzPackageOrContainerId,
+    __in_z_opt LPCWSTR wzPayloadId,
+    __in HRESULT hrStatus,
+    __inout BOOTSTRAPPER_CACHEVERIFYCOMPLETE_ACTION* pAction
+    );
+BAAPI UserExperienceOnDetectBegin(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in BOOL fInstalled,
+    __in DWORD cPackages
+    );
+BAAPI UserExperienceOnDetectCompatibleMsiPackage(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in_z LPCWSTR wzPackageId,
+    __in_z LPCWSTR wzCompatiblePackageId,
+    __in DWORD64 dw64CompatiblePackageVersion
+    );
+BAAPI UserExperienceOnDetectComplete(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in HRESULT hrStatus
+    );
+BAAPI UserExperienceOnDetectForwardCompatibleBundle(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in_z LPCWSTR wzBundleId,
+    __in BOOTSTRAPPER_RELATION_TYPE relationType,
+    __in_z LPCWSTR wzBundleTag,
+    __in BOOL fPerMachine,
+    __in DWORD64 dw64Version,
+    __inout BOOL* pfIgnoreBundle
+    );
+BAAPI UserExperienceOnDetectMsiFeature(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in_z LPCWSTR wzPackageId,
+    __in_z LPCWSTR wzFeatureId,
+    __in BOOTSTRAPPER_FEATURE_STATE state
+    );
+BAAPI UserExperienceOnDetectPackageBegin(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in_z LPCWSTR wzPackageId
+    );
+BAAPI UserExperienceOnDetectPackageComplete(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in_z LPCWSTR wzPackageId,
+    __in HRESULT hrStatus,
+    __in BOOTSTRAPPER_PACKAGE_STATE state
+    );
+BAAPI UserExperienceOnDetectRelatedBundle(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in_z LPCWSTR wzBundleId,
+    __in BOOTSTRAPPER_RELATION_TYPE relationType,
+    __in_z LPCWSTR wzBundleTag,
+    __in BOOL fPerMachine,
+    __in DWORD64 dw64Version,
+    __in BOOTSTRAPPER_RELATED_OPERATION operation
+    );
+BAAPI UserExperienceOnDetectRelatedMsiPackage(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in_z LPCWSTR wzPackageId,
+    __in_z LPCWSTR wzUpgradeCode,
+    __in_z LPCWSTR wzProductCode,
+    __in BOOL fPerMachine,
+    __in DWORD64 dw64Version,
+    __in BOOTSTRAPPER_RELATED_OPERATION operation
+    );
+BAAPI UserExperienceOnDetectTargetMsiPackage(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in_z LPCWSTR wzPackageId,
+    __in_z LPCWSTR wzProductCode,
+    __in BOOTSTRAPPER_PACKAGE_STATE patchState
+    );
+BAAPI UserExperienceOnDetectUpdate(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in_z LPCWSTR wzUpdateLocation,
+    __in DWORD64 dw64Size,
+    __in DWORD64 dw64Version,
+    __in_z_opt LPCWSTR wzTitle,
+    __in_z_opt LPCWSTR wzSummary,
+    __in_z_opt LPCWSTR wzContentType,
+    __in_z_opt LPCWSTR wzContent,
+    __inout BOOL* pfStopProcessingUpdates
+    );
+BAAPI UserExperienceOnDetectUpdateBegin(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in_z LPCWSTR wzUpdateLocation,
+    __inout BOOL* pfSkip
+    );
+BAAPI UserExperienceOnDetectUpdateComplete(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in HRESULT hrStatus,
+    __inout BOOL* pfIgnoreError
+    );
+BAAPI UserExperienceOnElevateBegin(
+    __in BURN_USER_EXPERIENCE* pUserExperience
+    );
+BAAPI UserExperienceOnElevateComplete(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in HRESULT hrStatus
+    );
+BAAPI UserExperienceOnError(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in BOOTSTRAPPER_ERROR_TYPE errorType,
+    __in_z_opt LPCWSTR wzPackageId,
+    __in DWORD dwCode,
+    __in_z_opt LPCWSTR wzError,
+    __in DWORD dwUIHint,
+    __in DWORD cData,
+    __in_ecount_z_opt(cData) LPCWSTR* rgwzData,
+    __inout int* pnResult
+    );
+BAAPI UserExperienceOnExecuteBegin(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in DWORD cExecutingPackages
+    );
+BAAPI UserExperienceOnExecuteComplete(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in HRESULT hrStatus
+);
+BAAPI UserExperienceOnExecuteFilesInUse(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in_z LPCWSTR wzPackageId,
+    __in DWORD cFiles,
+    __in_ecount_z_opt(cFiles) LPCWSTR* rgwzFiles,
+    __inout int* pnResult
+    );
+BAAPI UserExperienceOnExecuteMsiMessage(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in_z LPCWSTR wzPackageId,
+    __in INSTALLMESSAGE messageType,
+    __in DWORD dwUIHint,
+    __in_z LPCWSTR wzMessage,
+    __in DWORD cData,
+    __in_ecount_z_opt(cData) LPCWSTR* rgwzData,
+    __inout int* pnResult
+    );
+BAAPI UserExperienceOnExecutePackageBegin(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in_z LPCWSTR wzPackageId,
+    __in BOOL fExecute
+    );
+BAAPI UserExperienceOnExecutePackageComplete(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in_z LPCWSTR wzPackageId,
+    __in HRESULT hrStatus,
+    __in BOOTSTRAPPER_APPLY_RESTART restart,
+    __inout BOOTSTRAPPER_EXECUTEPACKAGECOMPLETE_ACTION* pAction
+    );
+BAAPI UserExperienceOnExecutePatchTarget(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in_z LPCWSTR wzPackageId,
+    __in_z LPCWSTR wzTargetProductCode
+    );
+BAAPI UserExperienceOnExecuteProgress(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in_z LPCWSTR wzPackageId,
+    __in DWORD dwProgressPercentage,
+    __in DWORD dwOverallPercentage,
+    __inout int* pnResult
+    );
+BAAPI UserExperienceOnLaunchApprovedExeBegin(
+    __in BURN_USER_EXPERIENCE* pUserExperience
+    );
+BAAPI UserExperienceOnLaunchApprovedExeComplete(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in HRESULT hrStatus,
+    __in DWORD dwProcessId
+    );
+BAAPI UserExperienceOnPlanBegin(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in DWORD cPackages
+    );
+BAAPI UserExperienceOnPlanCompatibleMsiPackageBegin(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in_z LPCWSTR wzPackageId,
+    __in_z LPCWSTR wzCompatiblePackageId,
+    __in DWORD64 dw64CompatiblePackageVersion,
+    __inout BOOTSTRAPPER_REQUEST_STATE* pRequestedState
+    );
+BAAPI UserExperienceOnPlanCompatibleMsiPackageComplete(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in_z LPCWSTR wzPackageId,
+    __in_z LPCWSTR wzCompatiblePackageId,
+    __in HRESULT hrStatus,
+    __in BOOTSTRAPPER_PACKAGE_STATE state,
+    __in BOOTSTRAPPER_REQUEST_STATE requested,
+    __in BOOTSTRAPPER_ACTION_STATE execute,
+    __in BOOTSTRAPPER_ACTION_STATE rollback
+    );
+BAAPI UserExperienceOnPlanComplete(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in HRESULT hrStatus
+    );
+BAAPI UserExperienceOnPlanMsiFeature(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in_z LPCWSTR wzPackageId,
+    __in_z LPCWSTR wzFeatureId,
+    __inout BOOTSTRAPPER_FEATURE_STATE* pRequestedState
+    );
+BAAPI UserExperienceOnPlanPackageBegin(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in_z LPCWSTR wzPackageId,
+    __inout BOOTSTRAPPER_REQUEST_STATE* pRequestedState
+    );
+BAAPI UserExperienceOnPlanPackageComplete(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in_z LPCWSTR wzPackageId,
+    __in HRESULT hrStatus,
+    __in BOOTSTRAPPER_PACKAGE_STATE state,
+    __in BOOTSTRAPPER_REQUEST_STATE requested,
+    __in BOOTSTRAPPER_ACTION_STATE execute,
+    __in BOOTSTRAPPER_ACTION_STATE rollback
+    );
+BAAPI UserExperienceOnPlanRelatedBundle(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in_z LPCWSTR wzBundleId,
+    __inout BOOTSTRAPPER_REQUEST_STATE* pRequestedState
+    );
+BAAPI UserExperienceOnPlanTargetMsiPackage(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in_z LPCWSTR wzPackageId,
+    __in_z LPCWSTR wzProductCode,
+    __inout BOOTSTRAPPER_REQUEST_STATE* pRequestedState
+    );
+BAAPI UserExperienceOnProgress(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in BOOL fRollback,
+    __in DWORD dwProgressPercentage,
+    __in DWORD dwOverallPercentage
+    );
+BAAPI UserExperienceOnRegisterBegin(
+    __in BURN_USER_EXPERIENCE* pUserExperience
+    );
+BAAPI UserExperienceOnRegisterComplete(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in HRESULT hrStatus
+    );
+BAAPI UserExperienceOnResolveSource(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in_z LPCWSTR wzPackageOrContainerId,
+    __in_z_opt LPCWSTR wzPayloadId,
+    __in_z LPCWSTR wzLocalSource,
+    __in_z_opt LPCWSTR wzDownloadSource,
+    __inout BOOTSTRAPPER_RESOLVESOURCE_ACTION* pAction
+    );
+BAAPI UserExperienceOnShutdown(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __inout BOOTSTRAPPER_SHUTDOWN_ACTION* pAction
+    );
+BAAPI UserExperienceOnStartup(
+    __in BURN_USER_EXPERIENCE* pUserExperience
+    );
+BAAPI UserExperienceOnSystemShutdown(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in DWORD dwEndSession,
+    __inout BOOL* pfCancel
+    );
+BAAPI UserExperienceOnUnregisterBegin(
+    __in BURN_USER_EXPERIENCE* pUserExperience
+    );
+BAAPI UserExperienceOnUnregisterComplete(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in HRESULT hrStatus
+    );
+HRESULT UserExperienceInterpretResult(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in DWORD dwAllowedResults,
+    __in int nResult
+    );
+int UserExperienceCheckExecuteResult(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in BOOL fRollback,
+    __in DWORD dwAllowedResults,
+    __in int nResult
+    );
+HRESULT UserExperienceInterpretExecuteResult(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in BOOL fRollback,
+    __in DWORD dwAllowedResults,
+    __in int nResult
+    );
+#if defined(__cplusplus)
+}
+#endif
diff --git a/src/engine/variable.cpp b/src/engine/variable.cpp
new file mode 100644
index 00000000..ed4abea2
--- /dev/null
+++ b/src/engine/variable.cpp
@@ -0,0 +1,2345 @@
+// 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.
+
+#include "precomp.h"
+
+
+// structs
+
+typedef const struct _BUILT_IN_VARIABLE_DECLARATION
+{
+    LPCWSTR wzVariable;
+    PFN_INITIALIZEVARIABLE pfnInitialize;
+    DWORD_PTR dwpInitializeData;
+    BOOL fPersist;
+    BOOL fOverridable;
+} BUILT_IN_VARIABLE_DECLARATION;
+
+
+// constants
+
+const DWORD GROW_VARIABLE_ARRAY = 3;
+
+enum OS_INFO_VARIABLE
+{
+    OS_INFO_VARIABLE_NONE,
+    OS_INFO_VARIABLE_VersionNT,
+    OS_INFO_VARIABLE_VersionNT64,
+    OS_INFO_VARIABLE_ServicePackLevel,
+    OS_INFO_VARIABLE_NTProductType,
+    OS_INFO_VARIABLE_NTSuiteBackOffice,
+    OS_INFO_VARIABLE_NTSuiteDataCenter,
+    OS_INFO_VARIABLE_NTSuiteEnterprise,
+    OS_INFO_VARIABLE_NTSuitePersonal,
+    OS_INFO_VARIABLE_NTSuiteSmallBusiness,
+    OS_INFO_VARIABLE_NTSuiteSmallBusinessRestricted,
+    OS_INFO_VARIABLE_NTSuiteWebServer,
+    OS_INFO_VARIABLE_CompatibilityMode,
+    OS_INFO_VARIABLE_TerminalServer,
+    OS_INFO_VARIABLE_ProcessorArchitecture,
+};
+
+enum SET_VARIABLE
+{
+    SET_VARIABLE_NOT_BUILTIN,
+    SET_VARIABLE_OVERRIDE_BUILTIN,
+    SET_VARIABLE_OVERRIDE_PERSISTED_BUILTINS,
+    SET_VARIABLE_ANY,
+};
+
+// internal function declarations
+
+static HRESULT FormatString(
+    __in BURN_VARIABLES* pVariables,
+    __in_z LPCWSTR wzIn,
+    __out_z_opt LPWSTR* psczOut,
+    __out_opt DWORD* pcchOut,
+    __in BOOL fObfuscateHiddenVariables
+    );
+static HRESULT AddBuiltInVariable(
+    __in BURN_VARIABLES* pVariables,
+    __in LPCWSTR wzVariable,
+    __in PFN_INITIALIZEVARIABLE pfnInitialize,
+    __in DWORD_PTR dwpInitializeData,
+    __in BOOL fPersist,
+    __in BOOL fOverridable
+    );
+static HRESULT GetVariable(
+    __in BURN_VARIABLES* pVariables,
+    __in_z LPCWSTR wzVariable,
+    __out BURN_VARIABLE** ppVariable
+    );
+static HRESULT FindVariableIndexByName(
+    __in BURN_VARIABLES* pVariables,
+    __in_z LPCWSTR wzVariable,
+    __out DWORD* piVariable
+    );
+static HRESULT InsertVariable(
+    __in BURN_VARIABLES* pVariables,
+    __in_z LPCWSTR wzVariable,
+    __in DWORD iPosition
+    );
+static HRESULT SetVariableValue(
+    __in BURN_VARIABLES* pVariables,
+    __in_z LPCWSTR wzVariable,
+    __in BURN_VARIANT* pVariant,
+    __in BOOL fLiteral,
+    __in SET_VARIABLE setBuiltin,
+    __in BOOL fLog
+    );
+static HRESULT InitializeVariableVersionNT(
+    __in DWORD_PTR dwpData,
+    __inout BURN_VARIANT* pValue
+    );
+static HRESULT InitializeVariableOsInfo(
+    __in DWORD_PTR dwpData,
+    __inout BURN_VARIANT* pValue
+    );
+static HRESULT InitializeVariableSystemInfo(
+    __in DWORD_PTR dwpData,
+    __inout BURN_VARIANT* pValue
+    );
+static HRESULT InitializeVariableComputerName(
+    __in DWORD_PTR dwpData,
+    __inout BURN_VARIANT* pValue
+    );
+static HRESULT InitializeVariableVersionMsi(
+    __in DWORD_PTR dwpData,
+    __inout BURN_VARIANT* pValue
+    );
+static HRESULT InitializeVariableCsidlFolder(
+    __in DWORD_PTR dwpData,
+    __inout BURN_VARIANT* pValue
+    );
+static HRESULT InitializeVariableWindowsVolumeFolder(
+    __in DWORD_PTR dwpData,
+    __inout BURN_VARIANT* pValue
+    );
+static HRESULT InitializeVariableTempFolder(
+    __in DWORD_PTR dwpData,
+    __inout BURN_VARIANT* pValue
+    );
+static HRESULT InitializeVariableSystemFolder(
+    __in DWORD_PTR dwpData,
+    __inout BURN_VARIANT* pValue
+    );
+static HRESULT InitializeVariablePrivileged(
+    __in DWORD_PTR dwpData,
+    __inout BURN_VARIANT* pValue
+    );
+static HRESULT InitializeVariableRebootPending(
+    __in DWORD_PTR dwpData,
+    __inout BURN_VARIANT* pValue
+    );
+static HRESULT InitializeSystemLanguageID(
+    __in DWORD_PTR dwpData,
+    __inout BURN_VARIANT* pValue
+    );
+static HRESULT InitializeUserUILanguageID(
+    __in DWORD_PTR dwpData,
+    __inout BURN_VARIANT* pValue
+    );
+static HRESULT InitializeUserLanguageID(
+    __in DWORD_PTR dwpData,
+    __inout BURN_VARIANT* pValue
+    );
+static HRESULT InitializeVariableString(
+    __in DWORD_PTR dwpData,
+    __inout BURN_VARIANT* pValue
+    );
+static HRESULT InitializeVariableNumeric(
+    __in DWORD_PTR dwpData,
+    __inout BURN_VARIANT* pValue
+    );
+static HRESULT InitializeVariableRegistryFolder(
+    __in DWORD_PTR dwpData,
+    __inout BURN_VARIANT* pValue
+    );
+static HRESULT InitializeVariable6432Folder(
+        __in DWORD_PTR dwpData,
+    __inout BURN_VARIANT* pValue
+    );
+static HRESULT InitializeVariableDate(
+    __in DWORD_PTR dwpData,
+    __inout BURN_VARIANT* pValue
+    );
+static HRESULT InitializeVariableInstallerName(
+    __in DWORD_PTR dwpData,
+    __inout BURN_VARIANT* pValue
+    );
+static HRESULT InitializeVariableInstallerVersion(
+    __in DWORD_PTR dwpData,
+    __inout BURN_VARIANT* pValue
+    );
+static HRESULT InitializeVariableVersion(
+    __in DWORD_PTR dwpData,
+    __inout BURN_VARIANT* pValue
+    );
+static HRESULT InitializeVariableLogonUser(
+    __in DWORD_PTR dwpData,
+    __inout BURN_VARIANT* pValue
+    );
+static HRESULT Get64bitFolderFromRegistry(
+    __in int nFolder,
+    __deref_out_z LPWSTR* psczPath
+    );
+
+
+// function definitions
+
+extern "C" HRESULT VariableInitialize(
+    __in BURN_VARIABLES* pVariables
+    )
+{
+    HRESULT hr = S_OK;
+
+    ::InitializeCriticalSection(&pVariables->csAccess);
+
+    const BUILT_IN_VARIABLE_DECLARATION vrgBuiltInVariables[] = {
+        {L"AdminToolsFolder", InitializeVariableCsidlFolder, CSIDL_ADMINTOOLS},
+        {L"AppDataFolder", InitializeVariableCsidlFolder, CSIDL_APPDATA},
+        {L"CommonAppDataFolder", InitializeVariableCsidlFolder, CSIDL_COMMON_APPDATA},
+#if defined(_WIN64)
+        {L"CommonFiles64Folder", InitializeVariableCsidlFolder, CSIDL_PROGRAM_FILES_COMMON},
+        {L"CommonFilesFolder", InitializeVariableCsidlFolder, CSIDL_PROGRAM_FILES_COMMONX86},
+#else
+        {L"CommonFiles64Folder", InitializeVariableRegistryFolder, CSIDL_PROGRAM_FILES_COMMON},
+        {L"CommonFilesFolder", InitializeVariableCsidlFolder, CSIDL_PROGRAM_FILES_COMMON},
+#endif
+        {L"CommonFiles6432Folder", InitializeVariable6432Folder, CSIDL_PROGRAM_FILES_COMMON},
+        {L"CompatibilityMode", InitializeVariableOsInfo, OS_INFO_VARIABLE_CompatibilityMode},
+        {VARIABLE_DATE, InitializeVariableDate, 0},
+        {L"ComputerName", InitializeVariableComputerName, 0},
+        {L"DesktopFolder", InitializeVariableCsidlFolder, CSIDL_DESKTOP},
+        {L"FavoritesFolder", InitializeVariableCsidlFolder, CSIDL_FAVORITES},
+        {L"FontsFolder", InitializeVariableCsidlFolder, CSIDL_FONTS},
+        {VARIABLE_INSTALLERNAME, InitializeVariableInstallerName, 0},
+        {VARIABLE_INSTALLERVERSION, InitializeVariableInstallerVersion, 0},
+        {L"LocalAppDataFolder", InitializeVariableCsidlFolder, CSIDL_LOCAL_APPDATA},
+        {VARIABLE_LOGONUSER, InitializeVariableLogonUser, 0},
+        {L"MyPicturesFolder", InitializeVariableCsidlFolder, CSIDL_MYPICTURES},
+        {L"NTProductType", InitializeVariableOsInfo, OS_INFO_VARIABLE_NTProductType},
+        {L"NTSuiteBackOffice", InitializeVariableOsInfo, OS_INFO_VARIABLE_NTSuiteBackOffice},
+        {L"NTSuiteDataCenter", InitializeVariableOsInfo, OS_INFO_VARIABLE_NTSuiteDataCenter},
+        {L"NTSuiteEnterprise", InitializeVariableOsInfo, OS_INFO_VARIABLE_NTSuiteEnterprise},
+        {L"NTSuitePersonal", InitializeVariableOsInfo, OS_INFO_VARIABLE_NTSuitePersonal},
+        {L"NTSuiteSmallBusiness", InitializeVariableOsInfo, OS_INFO_VARIABLE_NTSuiteSmallBusiness},
+        {L"NTSuiteSmallBusinessRestricted", InitializeVariableOsInfo, OS_INFO_VARIABLE_NTSuiteSmallBusinessRestricted},
+        {L"NTSuiteWebServer", InitializeVariableOsInfo, OS_INFO_VARIABLE_NTSuiteWebServer},
+        {L"PersonalFolder", InitializeVariableCsidlFolder, CSIDL_PERSONAL},
+        {L"Privileged", InitializeVariablePrivileged, 0},
+        {L"ProcessorArchitecture", InitializeVariableSystemInfo, OS_INFO_VARIABLE_ProcessorArchitecture},
+#if defined(_WIN64)
+        {L"ProgramFiles64Folder", InitializeVariableCsidlFolder, CSIDL_PROGRAM_FILES},
+        {L"ProgramFilesFolder", InitializeVariableCsidlFolder, CSIDL_PROGRAM_FILESX86},
+#else
+        {L"ProgramFiles64Folder", InitializeVariableRegistryFolder, CSIDL_PROGRAM_FILES},
+        {L"ProgramFilesFolder", InitializeVariableCsidlFolder, CSIDL_PROGRAM_FILES},
+#endif
+        {L"ProgramFiles6432Folder", InitializeVariable6432Folder, CSIDL_PROGRAM_FILES},
+        {L"ProgramMenuFolder", InitializeVariableCsidlFolder, CSIDL_PROGRAMS},
+        {L"RebootPending", InitializeVariableRebootPending, 0},
+        {L"SendToFolder", InitializeVariableCsidlFolder, CSIDL_SENDTO},
+        {L"ServicePackLevel", InitializeVariableVersionNT, OS_INFO_VARIABLE_ServicePackLevel},
+        {L"StartMenuFolder", InitializeVariableCsidlFolder, CSIDL_STARTMENU},
+        {L"StartupFolder", InitializeVariableCsidlFolder, CSIDL_STARTUP},
+        {L"SystemFolder", InitializeVariableSystemFolder, FALSE},
+        {L"System64Folder", InitializeVariableSystemFolder, TRUE},
+        {L"SystemLanguageID", InitializeSystemLanguageID, 0},
+        {L"TempFolder", InitializeVariableTempFolder, 0},
+        {L"TemplateFolder", InitializeVariableCsidlFolder, CSIDL_TEMPLATES},
+        {L"TerminalServer", InitializeVariableOsInfo, OS_INFO_VARIABLE_TerminalServer},
+        {L"UserUILanguageID", InitializeUserUILanguageID, 0},
+        {L"UserLanguageID", InitializeUserLanguageID, 0},
+        {L"VersionMsi", InitializeVariableVersionMsi, 0},
+        {L"VersionNT", InitializeVariableVersionNT, OS_INFO_VARIABLE_VersionNT},
+        {L"VersionNT64", InitializeVariableVersionNT, OS_INFO_VARIABLE_VersionNT64},
+        {L"WindowsFolder", InitializeVariableCsidlFolder, CSIDL_WINDOWS},
+        {L"WindowsVolume", InitializeVariableWindowsVolumeFolder, 0},
+        {BURN_BUNDLE_ACTION, InitializeVariableNumeric, 0, FALSE, TRUE},
+        {BURN_BUNDLE_EXECUTE_PACKAGE_CACHE_FOLDER, InitializeVariableString, NULL, FALSE, TRUE},
+        {BURN_BUNDLE_EXECUTE_PACKAGE_ACTION, InitializeVariableString, NULL, FALSE, TRUE},
+        {BURN_BUNDLE_FORCED_RESTART_PACKAGE, InitializeVariableString, NULL, TRUE, TRUE},
+        {BURN_BUNDLE_INSTALLED, InitializeVariableNumeric, 0, FALSE, TRUE},
+        {BURN_BUNDLE_ELEVATED, InitializeVariableNumeric, 0, FALSE, TRUE},
+        {BURN_BUNDLE_ACTIVE_PARENT, InitializeVariableString, NULL, FALSE, TRUE},
+        {BURN_BUNDLE_PROVIDER_KEY, InitializeVariableString, (DWORD_PTR)L"", FALSE, TRUE},
+        {BURN_BUNDLE_SOURCE_PROCESS_PATH, InitializeVariableString, NULL, FALSE, TRUE},
+        {BURN_BUNDLE_SOURCE_PROCESS_FOLDER, InitializeVariableString, NULL, FALSE, TRUE},
+        {BURN_BUNDLE_TAG, InitializeVariableString, (DWORD_PTR)L"", FALSE, TRUE},
+        {BURN_BUNDLE_UILEVEL, InitializeVariableNumeric, 0, FALSE, TRUE},
+        {BURN_BUNDLE_VERSION, InitializeVariableVersion, 0, FALSE, TRUE},
+    };
+
+    for (DWORD i = 0; i < countof(vrgBuiltInVariables); ++i)
+    {
+        BUILT_IN_VARIABLE_DECLARATION* pBuiltInVariable = &vrgBuiltInVariables[i];
+
+        hr = AddBuiltInVariable(pVariables, pBuiltInVariable->wzVariable, pBuiltInVariable->pfnInitialize, pBuiltInVariable->dwpInitializeData, pBuiltInVariable->fPersist, pBuiltInVariable->fOverridable);
+        ExitOnFailure(hr, "Failed to add built-in variable: %ls.", pBuiltInVariable->wzVariable);
+    }
+
+LExit:
+    return hr;
+}
+
+extern "C" HRESULT VariablesParseFromXml(
+    __in BURN_VARIABLES* pVariables,
+    __in IXMLDOMNode* pixnBundle
+    )
+{
+    HRESULT hr = S_OK;
+    IXMLDOMNodeList* pixnNodes = NULL;
+    IXMLDOMNode* pixnNode = NULL;
+    DWORD cNodes = 0;
+    LPWSTR sczId = NULL;
+    LPWSTR scz = NULL;
+    BURN_VARIANT value = { };
+    BURN_VARIANT_TYPE valueType = BURN_VARIANT_TYPE_NONE;
+    BOOL fHidden = FALSE;
+    BOOL fPersisted = FALSE;
+    DWORD iVariable = 0;
+
+    ::EnterCriticalSection(&pVariables->csAccess);
+
+    // select variable nodes
+    hr = XmlSelectNodes(pixnBundle, L"Variable", &pixnNodes);
+    ExitOnFailure(hr, "Failed to select variable nodes.");
+
+    // get variable node count
+    hr = pixnNodes->get_length((long*)&cNodes);
+    ExitOnFailure(hr, "Failed to get variable node count.");
+
+    // parse package elements
+    for (DWORD i = 0; i < cNodes; ++i)
+    {
+        hr = XmlNextElement(pixnNodes, &pixnNode, NULL);
+        ExitOnFailure(hr, "Failed to get next node.");
+
+        // @Id
+        hr = XmlGetAttributeEx(pixnNode, L"Id", &sczId);
+        ExitOnFailure(hr, "Failed to get @Id.");
+
+        // @Hidden
+        hr = XmlGetYesNoAttribute(pixnNode, L"Hidden", &fHidden);
+        ExitOnFailure(hr, "Failed to get @Hidden.");
+
+        // @Persisted
+        hr = XmlGetYesNoAttribute(pixnNode, L"Persisted", &fPersisted);
+        ExitOnFailure(hr, "Failed to get @Persisted.");
+
+        // @Value
+        hr = XmlGetAttributeEx(pixnNode, L"Value", &scz);
+        if (E_NOTFOUND != hr)
+        {
+            ExitOnFailure(hr, "Failed to get @Value.");
+
+            hr = BVariantSetString(&value, scz, 0);
+            ExitOnFailure(hr, "Failed to set variant value.");
+
+            // @Type
+            hr = XmlGetAttributeEx(pixnNode, L"Type", &scz);
+            ExitOnFailure(hr, "Failed to get @Type.");
+
+            if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, scz, -1, L"numeric", -1))
+            {
+                if (!fHidden)
+                {
+                    LogStringLine(REPORT_STANDARD, "Initializing numeric variable '%ls' to value '%ls'", sczId, value.sczValue);
+                }
+                valueType = BURN_VARIANT_TYPE_NUMERIC;
+            }
+            else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, scz, -1, L"string", -1))
+            {
+                if (!fHidden)
+                {
+                    LogStringLine(REPORT_STANDARD, "Initializing string variable '%ls' to value '%ls'", sczId, value.sczValue);
+                }
+                valueType = BURN_VARIANT_TYPE_STRING;
+            }
+            else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, scz, -1, L"version", -1))
+            {
+                if (!fHidden)
+                {
+                    LogStringLine(REPORT_STANDARD, "Initializing version variable '%ls' to value '%ls'", sczId, value.sczValue);
+                }
+                valueType = BURN_VARIANT_TYPE_VERSION;
+            }
+            else
+            {
+                hr = E_INVALIDARG;
+                ExitOnFailure(hr, "Invalid value for @Type: %ls", scz);
+            }
+        }
+        else
+        {
+            valueType = BURN_VARIANT_TYPE_NONE;
+        }
+
+        if (fHidden)
+        {
+            LogStringLine(REPORT_STANDARD, "Initializing hidden variable '%ls'", sczId);
+        }
+
+        // change value variant to correct type
+        hr = BVariantChangeType(&value, valueType);
+        ExitOnFailure(hr, "Failed to change variant type.");
+
+        // find existing variable
+        hr = FindVariableIndexByName(pVariables, sczId, &iVariable);
+        ExitOnFailure(hr, "Failed to find variable value '%ls'.", sczId);
+
+        // insert element if not found
+        if (S_FALSE == hr)
+        {
+            hr = InsertVariable(pVariables, sczId, iVariable);
+            ExitOnFailure(hr, "Failed to insert variable '%ls'.", sczId);
+        }
+        else if (BURN_VARIABLE_INTERNAL_TYPE_NORMAL < pVariables->rgVariables[iVariable].internalType)
+        {
+            hr = E_INVALIDARG;
+            ExitOnRootFailure(hr, "Attempt to set built-in variable value: %ls", sczId);
+        }
+        pVariables->rgVariables[iVariable].fHidden = fHidden;
+        pVariables->rgVariables[iVariable].fPersisted = fPersisted;
+
+        // update variable value
+        hr = BVariantSetValue(&pVariables->rgVariables[iVariable].Value, &value);
+        ExitOnFailure(hr, "Failed to set value of variable: %ls", sczId);
+
+        hr = BVariantSetEncryption(&pVariables->rgVariables[iVariable].Value, fHidden);
+        ExitOnFailure(hr, "Failed to set variant encryption");
+
+        // prepare next iteration
+        ReleaseNullObject(pixnNode);
+        BVariantUninitialize(&value);
+        ReleaseNullStrSecure(scz);
+    }
+
+LExit:
+    ::LeaveCriticalSection(&pVariables->csAccess);
+
+    ReleaseObject(pixnNodes);
+    ReleaseObject(pixnNode);
+    ReleaseStr(scz);
+    ReleaseStr(sczId);
+    BVariantUninitialize(&value);
+
+    return hr;
+}
+
+extern "C" void VariablesUninitialize(
+    __in BURN_VARIABLES* pVariables
+    )
+{
+    ::DeleteCriticalSection(&pVariables->csAccess);
+
+    if (pVariables->rgVariables)
+    {
+        for (DWORD i = 0; i < pVariables->cVariables; ++i)
+        {
+            BURN_VARIABLE* pVariable = &pVariables->rgVariables[i];
+            if (pVariable)
+            {
+                ReleaseStr(pVariable->sczName);
+                BVariantUninitialize(&pVariable->Value);
+            }
+        }
+        MemFree(pVariables->rgVariables);
+    }
+}
+
+extern "C" void VariablesDump(
+    __in BURN_VARIABLES* pVariables
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR sczValue = NULL;
+
+    for (DWORD i = 0; i < pVariables->cVariables; ++i)
+    {
+        BURN_VARIABLE* pVariable = &pVariables->rgVariables[i];
+        if (pVariable && BURN_VARIANT_TYPE_NONE != pVariable->Value.Type)
+        {
+            hr = StrAllocFormatted(&sczValue, L"%ls = [%ls]", pVariable->sczName, pVariable->sczName);
+            if (SUCCEEDED(hr))
+            {
+                if (pVariable->fHidden)
+                {
+                    hr = VariableFormatStringObfuscated(pVariables, sczValue, &sczValue, NULL);
+                }
+                else
+                {
+                    hr = VariableFormatString(pVariables, sczValue, &sczValue, NULL);
+                }
+            }
+
+            if (FAILED(hr))
+            {
+                // already logged; best-effort to dump the rest on our way out the door
+                continue;
+            }
+
+            LogId(REPORT_VERBOSE, MSG_VARIABLE_DUMP, sczValue);
+
+            ReleaseNullStrSecure(sczValue);
+        }
+    }
+
+    StrSecureZeroFreeString(sczValue);
+}
+
+// The contents of pllValue may be sensitive, if variable is hidden should keep value encrypted and SecureZeroMemory.
+extern "C" HRESULT VariableGetNumeric(
+    __in BURN_VARIABLES* pVariables,
+    __in_z LPCWSTR wzVariable,
+    __out LONGLONG* pllValue
+    )
+{
+    HRESULT hr = S_OK;
+    BURN_VARIABLE* pVariable = NULL;
+
+    ::EnterCriticalSection(&pVariables->csAccess);
+
+    hr = GetVariable(pVariables, wzVariable, &pVariable);
+    if (SUCCEEDED(hr) && BURN_VARIANT_TYPE_NONE == pVariable->Value.Type)
+    {
+        ExitFunction1(hr = E_NOTFOUND);
+    }
+    else if (E_NOTFOUND == hr)
+    {
+        ExitFunction();
+    }
+    ExitOnFailure(hr, "Failed to get value of variable: %ls", wzVariable);
+
+    hr = BVariantGetNumeric(&pVariable->Value, pllValue);
+    ExitOnFailure(hr, "Failed to get value as numeric for variable: %ls", wzVariable);
+
+LExit:
+    ::LeaveCriticalSection(&pVariables->csAccess);
+
+    return hr;
+}
+
+// The contents of psczValue may be sensitive, if variable is hidden should keep encrypted and SecureZeroFree.
+extern "C" HRESULT VariableGetString(
+    __in BURN_VARIABLES* pVariables,
+    __in_z LPCWSTR wzVariable,
+    __out_z LPWSTR* psczValue
+    )
+{
+    HRESULT hr = S_OK;
+    BURN_VARIABLE* pVariable = NULL;
+
+    ::EnterCriticalSection(&pVariables->csAccess);
+
+    hr = GetVariable(pVariables, wzVariable, &pVariable);
+    if (SUCCEEDED(hr) && BURN_VARIANT_TYPE_NONE == pVariable->Value.Type)
+    {
+        ExitFunction1(hr = E_NOTFOUND);
+    }
+    else if (E_NOTFOUND == hr)
+    {
+        ExitFunction();
+    }
+    ExitOnFailure(hr, "Failed to get value of variable: %ls", wzVariable);
+
+    hr = BVariantGetString(&pVariable->Value, psczValue);
+    ExitOnFailure(hr, "Failed to get value as string for variable: %ls", wzVariable);
+
+LExit:
+    ::LeaveCriticalSection(&pVariables->csAccess);
+
+    return hr;
+}
+
+// The contents of pqwValue may be sensitive, if variable is hidden should keep value encrypted and SecureZeroMemory.
+extern "C" HRESULT VariableGetVersion(
+    __in BURN_VARIABLES* pVariables,
+    __in_z LPCWSTR wzVariable,
+    __in DWORD64* pqwValue
+    )
+{
+    HRESULT hr = S_OK;
+    BURN_VARIABLE* pVariable = NULL;
+
+    ::EnterCriticalSection(&pVariables->csAccess);
+
+    hr = GetVariable(pVariables, wzVariable, &pVariable);
+    if (SUCCEEDED(hr) && BURN_VARIANT_TYPE_NONE == pVariable->Value.Type)
+    {
+        ExitFunction1(hr = E_NOTFOUND);
+    }
+    else if (E_NOTFOUND == hr)
+    {
+        ExitFunction();
+    }
+    ExitOnFailure(hr, "Failed to get value of variable: %ls", wzVariable);
+
+    hr = BVariantGetVersion(&pVariable->Value, pqwValue);
+    ExitOnFailure(hr, "Failed to get value as version for variable: %ls", wzVariable);
+
+LExit:
+    ::LeaveCriticalSection(&pVariables->csAccess);
+
+    return hr;
+}
+
+extern "C" HRESULT VariableGetVariant(
+    __in BURN_VARIABLES* pVariables,
+    __in_z LPCWSTR wzVariable,
+    __in BURN_VARIANT* pValue
+    )
+{
+    HRESULT hr = S_OK;
+    BURN_VARIABLE* pVariable = NULL;
+
+    ::EnterCriticalSection(&pVariables->csAccess);
+
+    hr = GetVariable(pVariables, wzVariable, &pVariable);
+    if (E_NOTFOUND == hr)
+    {
+        ExitFunction();
+    }
+    ExitOnFailure(hr, "Failed to get value of variable: %ls", wzVariable);
+
+    hr = BVariantCopy(&pVariable->Value, pValue);
+    ExitOnFailure(hr, "Failed to copy value of variable: %ls", wzVariable);
+
+LExit:
+    ::LeaveCriticalSection(&pVariables->csAccess);
+
+    return hr;
+}
+
+// The contents of psczValue may be sensitive, should keep encrypted and SecureZeroFree.
+extern "C" HRESULT VariableGetFormatted(
+    __in BURN_VARIABLES* pVariables,
+    __in_z LPCWSTR wzVariable,
+    __out_z LPWSTR* psczValue
+    )
+{
+    HRESULT hr = S_OK;
+    BURN_VARIABLE* pVariable = NULL;
+    LPWSTR scz = NULL;
+
+    ::EnterCriticalSection(&pVariables->csAccess);
+
+    hr = GetVariable(pVariables, wzVariable, &pVariable);
+    if (SUCCEEDED(hr) && BURN_VARIANT_TYPE_NONE == pVariable->Value.Type)
+    {
+        ExitFunction1(hr = E_NOTFOUND);
+    }
+    else if (E_NOTFOUND == hr)
+    {
+        ExitFunction();
+    }
+    ExitOnFailure(hr, "Failed to get variable: %ls", wzVariable);
+
+    // Strings need to get expanded unless they're built-in or literal because they're guaranteed not to have embedded variables.
+    if (BURN_VARIANT_TYPE_STRING == pVariable->Value.Type &&
+        BURN_VARIABLE_INTERNAL_TYPE_NORMAL == pVariable->internalType &&
+        !pVariable->fLiteral)
+    {
+        hr = BVariantGetString(&pVariable->Value, &scz);
+        ExitOnFailure(hr, "Failed to get unformatted string.");
+
+        hr = VariableFormatString(pVariables, scz, psczValue, NULL);
+        ExitOnFailure(hr, "Failed to format value '%ls' of variable: %ls", pVariable->fHidden ? L"*****" : pVariable->Value.sczValue, wzVariable);
+    }
+    else
+    {
+        hr = BVariantGetString(&pVariable->Value, psczValue);
+        ExitOnFailure(hr, "Failed to get value as string for variable: %ls", wzVariable);
+    }
+
+LExit:
+    ::LeaveCriticalSection(&pVariables->csAccess);
+    StrSecureZeroFreeString(scz);
+
+    return hr;
+}
+
+extern "C" HRESULT VariableSetNumeric(
+    __in BURN_VARIABLES* pVariables,
+    __in_z LPCWSTR wzVariable,
+    __in LONGLONG llValue,
+    __in BOOL fOverwriteBuiltIn
+    )
+{
+    BURN_VARIANT variant = { };
+
+    // We're not going to encrypt this value, so can access the value directly.
+    variant.llValue = llValue;
+    variant.Type = BURN_VARIANT_TYPE_NUMERIC;
+
+    return SetVariableValue(pVariables, wzVariable, &variant, FALSE, fOverwriteBuiltIn ? SET_VARIABLE_OVERRIDE_BUILTIN : SET_VARIABLE_NOT_BUILTIN, TRUE);
+}
+
+extern "C" HRESULT VariableSetLiteralString(
+    __in BURN_VARIABLES* pVariables,
+    __in_z LPCWSTR wzVariable,
+    __in_z_opt LPCWSTR wzValue,
+    __in BOOL fOverwriteBuiltIn
+    )
+{
+    BURN_VARIANT variant = { };
+
+    // We're not going to encrypt this value, so can access the value directly.
+    variant.sczValue = (LPWSTR)wzValue;
+    variant.Type = BURN_VARIANT_TYPE_STRING;
+
+    return SetVariableValue(pVariables, wzVariable, &variant, TRUE, fOverwriteBuiltIn ? SET_VARIABLE_OVERRIDE_BUILTIN : SET_VARIABLE_NOT_BUILTIN, TRUE);
+}
+
+extern "C" HRESULT VariableSetString(
+    __in BURN_VARIABLES* pVariables,
+    __in_z LPCWSTR wzVariable,
+    __in_z_opt LPCWSTR wzValue,
+    __in BOOL fOverwriteBuiltIn
+    )
+{
+    BURN_VARIANT variant = { };
+
+    // We're not going to encrypt this value, so can access the value directly.
+    variant.sczValue = (LPWSTR)wzValue;
+    variant.Type = BURN_VARIANT_TYPE_STRING;
+
+    return SetVariableValue(pVariables, wzVariable, &variant, FALSE, fOverwriteBuiltIn ? SET_VARIABLE_OVERRIDE_BUILTIN : SET_VARIABLE_NOT_BUILTIN, TRUE);
+}
+
+extern "C" HRESULT VariableSetVersion(
+    __in BURN_VARIABLES* pVariables,
+    __in_z LPCWSTR wzVariable,
+    __in DWORD64 qwValue,
+    __in BOOL fOverwriteBuiltIn
+    )
+{
+    BURN_VARIANT variant = { };
+
+    // We're not going to encrypt this value, so can access the value directly.
+    variant.qwValue = qwValue;
+    variant.Type = BURN_VARIANT_TYPE_VERSION;
+
+    return SetVariableValue(pVariables, wzVariable, &variant, FALSE, fOverwriteBuiltIn ? SET_VARIABLE_OVERRIDE_BUILTIN : SET_VARIABLE_NOT_BUILTIN, TRUE);
+}
+
+extern "C" HRESULT VariableSetLiteralVariant(
+    __in BURN_VARIABLES* pVariables,
+    __in_z LPCWSTR wzVariable,
+    __in BURN_VARIANT* pVariant
+    )
+{
+    return SetVariableValue(pVariables, wzVariable, pVariant, TRUE, SET_VARIABLE_NOT_BUILTIN, TRUE);
+}
+
+// The contents of psczOut may be sensitive, should keep encrypted and SecureZeroFree
+extern "C" HRESULT VariableFormatString(
+    __in BURN_VARIABLES* pVariables,
+    __in_z LPCWSTR wzIn,
+    __out_z_opt LPWSTR* psczOut,
+    __out_opt DWORD* pcchOut
+    )
+{
+    return FormatString(pVariables, wzIn, psczOut, pcchOut, FALSE);
+}
+
+extern "C" HRESULT VariableFormatStringObfuscated(
+    __in BURN_VARIABLES* pVariables,
+    __in_z LPCWSTR wzIn,
+    __out_z_opt LPWSTR* psczOut,
+    __out_opt DWORD* pcchOut
+    )
+{
+    return FormatString(pVariables, wzIn, psczOut, pcchOut, TRUE);
+}
+
+extern "C" HRESULT VariableEscapeString(
+    __in_z LPCWSTR wzIn,
+    __out_z LPWSTR* psczOut
+    )
+{
+    HRESULT hr = S_OK;
+    LPCWSTR wzRead = NULL;
+    LPWSTR pwzEscaped = NULL;
+    LPWSTR pwz = NULL;
+    SIZE_T i = 0;
+
+    // allocate buffer for escaped string
+    hr = StrAlloc(&pwzEscaped, lstrlenW(wzIn) + 1);
+    ExitOnFailure(hr, "Failed to allocate buffer for escaped string.");
+
+    // read through string and move characters, inserting escapes as needed
+    wzRead = wzIn;
+    for (;;)
+    {
+        // find next character needing escaping
+        i = wcscspn(wzRead, L"[]{}");
+
+        // copy skipped characters
+        if (0 < i)
+        {
+            hr = StrAllocConcat(&pwzEscaped, wzRead, i);
+            ExitOnFailure(hr, "Failed to append characters.");
+        }
+
+        if (L'\0' == wzRead[i])
+        {
+            break; // end reached
+        }
+
+        // escape character
+        hr = StrAllocFormatted(&pwz, L"[\\%c]", wzRead[i]);
+        ExitOnFailure(hr, "Failed to format escape sequence.");
+
+        hr = StrAllocConcat(&pwzEscaped, pwz, 0);
+        ExitOnFailure(hr, "Failed to append escape sequence.");
+
+        // update read pointer
+        wzRead += i + 1;
+    }
+
+    // return value
+    hr = StrAllocString(psczOut, pwzEscaped, 0);
+    ExitOnFailure(hr, "Failed to copy string.");
+
+LExit:
+    ReleaseStr(pwzEscaped);
+    ReleaseStr(pwz);
+    return hr;
+}
+
+extern "C" HRESULT VariableSerialize(
+    __in BURN_VARIABLES* pVariables,
+    __in BOOL fPersisting,
+    __inout BYTE** ppbBuffer,
+    __inout SIZE_T* piBuffer
+    )
+{
+    HRESULT hr = S_OK;
+    BOOL fIncluded = FALSE;
+    LONGLONG ll = 0;
+    LPWSTR scz = NULL;
+    DWORD64 qw = 0;
+
+    ::EnterCriticalSection(&pVariables->csAccess);
+
+    // Write variable count.
+    hr = BuffWriteNumber(ppbBuffer, piBuffer, pVariables->cVariables);
+    ExitOnFailure(hr, "Failed to write variable count.");
+
+    // Write variables.
+    for (DWORD i = 0; i < pVariables->cVariables; ++i)
+    {
+        BURN_VARIABLE* pVariable = &pVariables->rgVariables[i];
+
+        // If we aren't persisting, include only variables that aren't rejected by the elevated process.
+        // If we are persisting, include only variables that should be persisted.
+        fIncluded = (!fPersisting && BURN_VARIABLE_INTERNAL_TYPE_BUILTIN != pVariable->internalType) ||
+                    (fPersisting && pVariable->fPersisted);
+
+        // Write included flag.
+        hr = BuffWriteNumber(ppbBuffer, piBuffer, (DWORD)fIncluded);
+        ExitOnFailure(hr, "Failed to write included flag.");
+
+        if (!fIncluded)
+        {
+            continue;
+        }
+
+        // Write variable name.
+        hr = BuffWriteString(ppbBuffer, piBuffer, pVariable->sczName);
+        ExitOnFailure(hr, "Failed to write variable name.");
+
+        // Write variable value type.
+        hr = BuffWriteNumber(ppbBuffer, piBuffer, (DWORD)pVariable->Value.Type);
+        ExitOnFailure(hr, "Failed to write variable value type.");
+
+        // Write variable value.
+        switch (pVariable->Value.Type)
+        {
+        case BURN_VARIANT_TYPE_NONE:
+            break;
+        case BURN_VARIANT_TYPE_NUMERIC:
+            hr = BVariantGetNumeric(&pVariable->Value, &ll);
+            ExitOnFailure(hr, "Failed to get numeric.");
+
+            hr = BuffWriteNumber64(ppbBuffer, piBuffer, static_cast<DWORD64>(ll));
+            ExitOnFailure(hr, "Failed to write variable value as number.");
+
+            SecureZeroMemory(&ll, sizeof(ll));
+            break;
+        case BURN_VARIANT_TYPE_VERSION:
+            hr = BVariantGetVersion(&pVariable->Value, &qw);
+            ExitOnFailure(hr, "Failed to get version.");
+
+            hr = BuffWriteNumber64(ppbBuffer, piBuffer, qw);
+            ExitOnFailure(hr, "Failed to write variable value as number.");
+
+            SecureZeroMemory(&qw, sizeof(qw));
+            break;
+        case BURN_VARIANT_TYPE_STRING:
+            hr = BVariantGetString(&pVariable->Value, &scz);
+            ExitOnFailure(hr, "Failed to get string.");
+
+            hr = BuffWriteString(ppbBuffer, piBuffer, scz);
+            ExitOnFailure(hr, "Failed to write variable value as string.");
+
+            ReleaseNullStrSecure(scz);
+            break;
+        default:
+            hr = E_INVALIDARG;
+            ExitOnFailure(hr, "Unsupported variable type.");
+        }
+
+        // Write literal flag.
+        hr = BuffWriteNumber(ppbBuffer, piBuffer, (DWORD)pVariable->fLiteral);
+        ExitOnFailure(hr, "Failed to write literal flag.");
+    }
+
+LExit:
+    ::LeaveCriticalSection(&pVariables->csAccess);
+    SecureZeroMemory(&ll, sizeof(ll));
+    SecureZeroMemory(&qw, sizeof(qw));
+    StrSecureZeroFreeString(scz);
+
+    return hr;
+}
+
+extern "C" HRESULT VariableDeserialize(
+    __in BURN_VARIABLES* pVariables,
+    __in BOOL fWasPersisted,
+    __in_bcount(cbBuffer) BYTE* pbBuffer,
+    __in SIZE_T cbBuffer,
+    __inout SIZE_T* piBuffer
+    )
+{
+    HRESULT hr = S_OK;
+    DWORD cVariables = 0;
+    LPWSTR sczName = NULL;
+    BOOL fIncluded = FALSE;
+    BOOL fLiteral = FALSE;
+    BURN_VARIANT value = { };
+    LPWSTR scz = NULL;
+    DWORD64 qw = 0;
+
+    ::EnterCriticalSection(&pVariables->csAccess);
+
+    // Read variable count.
+    hr = BuffReadNumber(pbBuffer, cbBuffer, piBuffer, &cVariables);
+    ExitOnFailure(hr, "Failed to read variable count.");
+
+    // Read variables.
+    for (DWORD i = 0; i < cVariables; ++i)
+    {
+        // Read variable included flag.
+        hr = BuffReadNumber(pbBuffer, cbBuffer, piBuffer, (DWORD*)&fIncluded);
+        ExitOnFailure(hr, "Failed to read variable included flag.");
+
+        if (!fIncluded)
+        {
+            continue; // if variable is not included, skip.
+        }
+
+        // Read variable name.
+        hr = BuffReadString(pbBuffer, cbBuffer, piBuffer, &sczName);
+        ExitOnFailure(hr, "Failed to read variable name.");
+
+        // Read variable value type.
+        hr = BuffReadNumber(pbBuffer, cbBuffer, piBuffer, (DWORD*)&value.Type);
+        ExitOnFailure(hr, "Failed to read variable value type.");
+
+        // Read variable value.
+        switch (value.Type)
+        {
+        case BURN_VARIANT_TYPE_NONE:
+            break;
+        case BURN_VARIANT_TYPE_NUMERIC:
+            hr = BuffReadNumber64(pbBuffer, cbBuffer, piBuffer, &qw);
+            ExitOnFailure(hr, "Failed to read variable value as number.");
+
+            hr = BVariantSetNumeric(&value, static_cast<LONGLONG>(qw));
+            ExitOnFailure(hr, "Failed to set variable value.");
+
+            SecureZeroMemory(&qw, sizeof(qw));
+            break;
+        case BURN_VARIANT_TYPE_VERSION:
+            hr = BuffReadNumber64(pbBuffer, cbBuffer, piBuffer, &qw);
+            ExitOnFailure(hr, "Failed to read variable value as number.");
+
+            hr = BVariantSetVersion(&value, qw);
+            ExitOnFailure(hr, "Failed to set variable value.");
+
+            SecureZeroMemory(&qw, sizeof(qw));
+            break;
+        case BURN_VARIANT_TYPE_STRING:
+            hr = BuffReadString(pbBuffer, cbBuffer, piBuffer, &scz);
+            ExitOnFailure(hr, "Failed to read variable value as string.");
+
+            hr = BVariantSetString(&value, scz, NULL);
+            ExitOnFailure(hr, "Failed to set variable value.");
+
+            ReleaseNullStrSecure(scz);
+            break;
+        default:
+            hr = E_INVALIDARG;
+            ExitOnFailure(hr, "Unsupported variable type.");
+        }
+
+        // Read variable literal flag.
+        hr = BuffReadNumber(pbBuffer, cbBuffer, piBuffer, (DWORD*)&fLiteral);
+        ExitOnFailure(hr, "Failed to read variable literal flag.");
+
+        // Set variable.
+        hr = SetVariableValue(pVariables, sczName, &value, fLiteral, fWasPersisted ? SET_VARIABLE_OVERRIDE_PERSISTED_BUILTINS : SET_VARIABLE_ANY, FALSE);
+        ExitOnFailure(hr, "Failed to set variable.");
+
+        // Clean up.
+        BVariantUninitialize(&value);
+    }
+
+LExit:
+    ::LeaveCriticalSection(&pVariables->csAccess);
+
+    ReleaseStr(sczName);
+    BVariantUninitialize(&value);
+    SecureZeroMemory(&qw, sizeof(qw));
+    StrSecureZeroFreeString(scz);
+
+    return hr;
+}
+
+extern "C" HRESULT VariableStrAlloc(
+    __in BOOL fZeroOnRealloc,
+    __deref_out_ecount_part(cch, 0) LPWSTR* ppwz,
+    __in DWORD_PTR cch
+    )
+{
+    HRESULT hr = S_OK;
+
+    if (fZeroOnRealloc)
+    {
+        hr = StrAllocSecure(ppwz, cch);
+    }
+    else
+    {
+        hr = StrAlloc(ppwz, cch);
+    }
+
+    return hr;
+}
+
+extern "C" HRESULT VariableStrAllocString(
+    __in BOOL fZeroOnRealloc,
+    __deref_out_ecount_z(cchSource + 1) LPWSTR* ppwz,
+    __in_z LPCWSTR wzSource,
+    __in DWORD_PTR cchSource
+    )
+{
+    HRESULT hr = S_OK;
+
+    if (fZeroOnRealloc)
+    {
+        hr = StrAllocStringSecure(ppwz, wzSource, cchSource);
+    }
+    else
+    {
+        hr = StrAllocString(ppwz, wzSource, cchSource);
+    }
+
+    return hr;
+}
+
+extern "C" HRESULT VariableStrAllocConcat(
+    __in BOOL fZeroOnRealloc,
+    __deref_out_z LPWSTR* ppwz,
+    __in_z LPCWSTR wzSource,
+    __in DWORD_PTR cchSource
+    )
+{
+    HRESULT hr = S_OK;
+
+    if (fZeroOnRealloc)
+    {
+        hr = StrAllocConcatSecure(ppwz, wzSource, cchSource);
+    }
+    else
+    {
+        hr = StrAllocConcat(ppwz, wzSource, cchSource);
+    }
+
+    return hr;
+}
+
+extern "C" HRESULT __cdecl VariableStrAllocFormatted(
+    __in BOOL fZeroOnRealloc,
+    __deref_out_z LPWSTR* ppwz,
+    __in __format_string LPCWSTR wzFormat,
+    ...
+    )
+{
+    HRESULT hr = S_OK;
+    va_list args;
+
+    va_start(args, wzFormat);
+    if (fZeroOnRealloc)
+    {
+        hr = StrAllocFormattedArgsSecure(ppwz, wzFormat, args);
+    }
+    else
+    {
+        hr = StrAllocFormattedArgs(ppwz, wzFormat, args);
+    }
+    va_end(args);
+
+    return hr;
+}
+
+extern "C" HRESULT VariableIsHidden(
+    __in BURN_VARIABLES* pVariables,
+    __in_z LPCWSTR wzVariable,
+    __out BOOL* pfHidden
+    )
+{
+    HRESULT hr = S_OK;
+    BURN_VARIABLE* pVariable = NULL;
+
+    ::EnterCriticalSection(&pVariables->csAccess);
+
+    hr = GetVariable(pVariables, wzVariable, &pVariable);
+    if (E_NOTFOUND == hr)
+    {
+        // A missing variable does not need its data hidden.
+        *pfHidden = FALSE;
+
+        ExitFunction1(hr = S_OK);
+    }
+    ExitOnFailure(hr, "Failed to get visibility of variable: %ls", wzVariable);
+
+    *pfHidden = pVariable->fHidden;
+
+LExit:
+    ::LeaveCriticalSection(&pVariables->csAccess);
+
+    return hr;
+}
+
+
+// internal function definitions
+
+// The contents of psczOut may be sensitive, should keep encrypted and SecureZeroFree.
+static HRESULT FormatString(
+    __in BURN_VARIABLES* pVariables,
+    __in_z LPCWSTR wzIn,
+    __out_z_opt LPWSTR* psczOut,
+    __out_opt DWORD* pcchOut,
+    __in BOOL fObfuscateHiddenVariables
+    )
+{
+    HRESULT hr = S_OK;
+    DWORD er = ERROR_SUCCESS;
+    LPWSTR sczUnformatted = NULL;
+    LPWSTR sczFormat = NULL;
+    LPCWSTR wzRead = NULL;
+    LPCWSTR wzOpen = NULL;
+    LPCWSTR wzClose = NULL;
+    LPWSTR scz = NULL;
+    LPWSTR* rgVariables = NULL;
+    DWORD cVariables = 0;
+    DWORD cch = 0;
+    BOOL fHidden = FALSE;
+    MSIHANDLE hRecord = NULL;
+
+    ::EnterCriticalSection(&pVariables->csAccess);
+
+    // allocate buffer for format string
+    hr = StrAlloc(&sczFormat, lstrlenW(wzIn) + 1);
+    ExitOnFailure(hr, "Failed to allocate buffer for format string.");
+
+    // read out variables from the unformatted string and build a format string
+    wzRead = wzIn;
+    for (;;)
+    {
+        // scan for opening '['
+        wzOpen = wcschr(wzRead, L'[');
+        if (!wzOpen)
+        {
+            // end reached, append the remainder of the string and end loop
+            hr = VariableStrAllocConcat(!fObfuscateHiddenVariables, &sczFormat, wzRead, 0);
+            ExitOnFailure(hr, "Failed to append string.");
+            break;
+        }
+
+        // scan for closing ']'
+        wzClose = wcschr(wzOpen + 1, L']');
+        if (!wzClose)
+        {
+            // end reached, treat unterminated expander as literal
+            hr = VariableStrAllocConcat(!fObfuscateHiddenVariables, &sczFormat, wzRead, 0);
+            ExitOnFailure(hr, "Failed to append string.");
+            break;
+        }
+        cch = wzClose - wzOpen - 1;
+
+        if (0 == cch)
+        {
+            // blank, copy all text including the terminator
+            hr = VariableStrAllocConcat(!fObfuscateHiddenVariables, &sczFormat, wzRead, (DWORD_PTR)(wzClose - wzRead) + 1);
+            ExitOnFailure(hr, "Failed to append string.");
+        }
+        else
+        {
+            // append text preceding expander
+            if (wzOpen > wzRead)
+            {
+                hr = VariableStrAllocConcat(!fObfuscateHiddenVariables, &sczFormat, wzRead, (DWORD_PTR)(wzOpen - wzRead));
+                ExitOnFailure(hr, "Failed to append string.");
+            }
+
+            // get variable name
+            hr = VariableStrAllocString(!fObfuscateHiddenVariables, &scz, wzOpen + 1, cch);
+            ExitOnFailure(hr, "Failed to get variable name.");
+
+            // allocate space in variable array
+            if (rgVariables)
+            {
+                LPVOID pv = MemReAlloc(rgVariables, sizeof(LPWSTR) * (cVariables + 1), TRUE);
+                ExitOnNull(pv, hr, E_OUTOFMEMORY, "Failed to reallocate variable array.");
+                rgVariables = (LPWSTR*)pv;
+            }
+            else
+            {
+                rgVariables = (LPWSTR*)MemAlloc(sizeof(LPWSTR) * (cVariables + 1), TRUE);
+                ExitOnNull(rgVariables, hr, E_OUTOFMEMORY, "Failed to allocate variable array.");
+            }
+
+            // set variable value
+            if (2 <= cch && L'\\' == wzOpen[1])
+            {
+                // escape sequence, copy character
+                hr = VariableStrAllocString(!fObfuscateHiddenVariables, &rgVariables[cVariables], &wzOpen[2], 1);
+            }
+            else
+            {
+                if (fObfuscateHiddenVariables)
+                {
+                    hr = VariableIsHidden(pVariables, scz, &fHidden);
+                    ExitOnFailure(hr, "Failed to determine variable visibility: '%ls'.", scz);
+                }
+
+                if (fHidden)
+                {
+                    hr = StrAllocString(&rgVariables[cVariables], L"*****", 0);
+                }
+                else
+                {
+                    // get formatted variable value
+                    hr = VariableGetFormatted(pVariables, scz, &rgVariables[cVariables]);
+                    if (E_NOTFOUND == hr) // variable not found
+                    {
+                        hr = StrAllocStringSecure(&rgVariables[cVariables], L"", 0);
+                    }
+                }
+            }
+            ExitOnFailure(hr, "Failed to set variable value.");
+            ++cVariables;
+
+            // append placeholder to format string
+            hr = VariableStrAllocFormatted(!fObfuscateHiddenVariables, &scz, L"[%d]", cVariables);
+            ExitOnFailure(hr, "Failed to format placeholder string.");
+
+            hr = VariableStrAllocConcat(!fObfuscateHiddenVariables, &sczFormat, scz, 0);
+            ExitOnFailure(hr, "Failed to append placeholder.");
+        }
+
+        // update read pointer
+        wzRead = wzClose + 1;
+    }
+
+    // create record
+    hRecord = ::MsiCreateRecord(cVariables);
+    ExitOnNull(hRecord, hr, E_OUTOFMEMORY, "Failed to allocate record.");
+
+    // set format string
+    er = ::MsiRecordSetStringW(hRecord, 0, sczFormat);
+    ExitOnWin32Error(er, hr, "Failed to set record format string.");
+
+    // copy record fields
+    for (DWORD i = 0; i < cVariables; ++i)
+    {
+        if (*rgVariables[i]) // not setting if blank
+        {
+            er = ::MsiRecordSetStringW(hRecord, i + 1, rgVariables[i]);
+            ExitOnWin32Error(er, hr, "Failed to set record string.");
+        }
+    }
+
+    // get formatted character count
+    cch = 0;
+#pragma prefast(push)
+#pragma prefast(disable:6298)
+    er = ::MsiFormatRecordW(NULL, hRecord, L"", &cch);
+#pragma prefast(pop)
+    if (ERROR_MORE_DATA != er)
+    {
+        ExitOnWin32Error(er, hr, "Failed to get formatted length.");
+    }
+
+    // return formatted string
+    if (psczOut)
+    {
+        hr = VariableStrAlloc(!fObfuscateHiddenVariables, &scz, ++cch);
+        ExitOnFailure(hr, "Failed to allocate string.");
+
+        er = ::MsiFormatRecordW(NULL, hRecord, scz, &cch);
+        ExitOnWin32Error(er, hr, "Failed to format record.");
+
+        hr = VariableStrAllocString(!fObfuscateHiddenVariables, psczOut, scz, 0);
+        ExitOnFailure(hr, "Failed to copy string.");
+    }
+
+    // return character count
+    if (pcchOut)
+    {
+        *pcchOut = cch;
+    }
+
+LExit:
+    ::LeaveCriticalSection(&pVariables->csAccess);
+
+    if (rgVariables)
+    {
+        for (DWORD i = 0; i < cVariables; ++i)
+        {
+            if (fObfuscateHiddenVariables)
+            {
+                ReleaseStr(rgVariables[i]);
+            }
+            else
+            {
+                StrSecureZeroFreeString(rgVariables[i]);
+            }
+        }
+        MemFree(rgVariables);
+    }
+
+    if (hRecord)
+    {
+        ::MsiCloseHandle(hRecord);
+    }
+
+    if (fObfuscateHiddenVariables)
+    {
+        ReleaseStr(sczUnformatted);
+        ReleaseStr(sczFormat);
+        ReleaseStr(scz);
+    }
+    else
+    {
+        StrSecureZeroFreeString(sczUnformatted);
+        StrSecureZeroFreeString(sczFormat);
+        StrSecureZeroFreeString(scz);
+    }
+
+    return hr;
+}
+
+static HRESULT AddBuiltInVariable(
+    __in BURN_VARIABLES* pVariables,
+    __in LPCWSTR wzVariable,
+    __in PFN_INITIALIZEVARIABLE pfnInitialize,
+    __in DWORD_PTR dwpInitializeData,
+    __in BOOL fPersist,
+    __in BOOL fOverridable
+    )
+{
+    HRESULT hr = S_OK;
+    DWORD iVariable = 0;
+    BURN_VARIABLE* pVariable = NULL;
+
+    hr = FindVariableIndexByName(pVariables, wzVariable, &iVariable);
+    ExitOnFailure(hr, "Failed to find variable value.");
+
+    // insert element if not found
+    if (S_FALSE == hr)
+    {
+        hr = InsertVariable(pVariables, wzVariable, iVariable);
+        ExitOnFailure(hr, "Failed to insert variable.");
+    }
+
+    // set variable values
+    pVariable = &pVariables->rgVariables[iVariable];
+    pVariable->fPersisted = fPersist;
+    pVariable->internalType = fOverridable ? BURN_VARIABLE_INTERNAL_TYPE_OVERRIDABLE_BUILTIN : BURN_VARIABLE_INTERNAL_TYPE_BUILTIN;
+    pVariable->pfnInitialize = pfnInitialize;
+    pVariable->dwpInitializeData = dwpInitializeData;
+
+LExit:
+    return hr;
+}
+
+static HRESULT GetVariable(
+    __in BURN_VARIABLES* pVariables,
+    __in_z LPCWSTR wzVariable,
+    __out BURN_VARIABLE** ppVariable
+    )
+{
+    HRESULT hr = S_OK;
+    DWORD iVariable = 0;
+    BURN_VARIABLE* pVariable = NULL;
+
+    hr = FindVariableIndexByName(pVariables, wzVariable, &iVariable);
+    ExitOnFailure(hr, "Failed to find variable value '%ls'.", wzVariable);
+
+    if (S_FALSE == hr)
+    {
+        ExitFunction1(hr = E_NOTFOUND);
+    }
+
+    pVariable = &pVariables->rgVariables[iVariable];
+
+    // initialize built-in variable
+    if (BURN_VARIANT_TYPE_NONE == pVariable->Value.Type && BURN_VARIABLE_INTERNAL_TYPE_NORMAL < pVariable->internalType)
+    {
+        hr = pVariable->pfnInitialize(pVariable->dwpInitializeData, &pVariable->Value);
+        ExitOnFailure(hr, "Failed to initialize built-in variable value '%ls'.", wzVariable);
+    }
+
+    *ppVariable = pVariable;
+
+LExit:
+    return hr;
+}
+
+static HRESULT FindVariableIndexByName(
+    __in BURN_VARIABLES* pVariables,
+    __in_z LPCWSTR wzVariable,
+    __out DWORD* piVariable
+    )
+{
+    HRESULT hr = S_OK;
+    DWORD iRangeFirst = 0;
+    DWORD cRangeLength = pVariables->cVariables;
+
+    while (cRangeLength)
+    {
+        // get variable in middle of range
+        DWORD iPosition = cRangeLength / 2;
+        BURN_VARIABLE* pVariable = &pVariables->rgVariables[iRangeFirst + iPosition];
+
+        switch (::CompareStringW(LOCALE_INVARIANT, SORT_STRINGSORT, wzVariable, -1, pVariable->sczName, -1))
+        {
+        case CSTR_LESS_THAN:
+            // restrict range to elements before the current
+            cRangeLength = iPosition;
+            break;
+        case CSTR_EQUAL:
+            // variable found
+            *piVariable = iRangeFirst + iPosition;
+            ExitFunction1(hr = S_OK);
+        case CSTR_GREATER_THAN:
+            // restrict range to elements after the current
+            iRangeFirst += iPosition + 1;
+            cRangeLength -= iPosition + 1;
+            break;
+        default:
+            ExitWithLastError(hr, "Failed to compare strings.");
+        }
+    }
+
+    *piVariable = iRangeFirst;
+    hr = S_FALSE; // variable not found
+
+LExit:
+    return hr;
+}
+
+static HRESULT InsertVariable(
+    __in BURN_VARIABLES* pVariables,
+    __in_z LPCWSTR wzVariable,
+    __in DWORD iPosition
+    )
+{
+    HRESULT hr = S_OK;
+    size_t cbAllocSize = 0;
+
+    // ensure there is room in the variable array
+    if (pVariables->cVariables == pVariables->dwMaxVariables)
+    {
+        hr = ::DWordAdd(pVariables->dwMaxVariables, GROW_VARIABLE_ARRAY, &(pVariables->dwMaxVariables));
+        ExitOnRootFailure(hr, "Overflow while growing variable array size");
+
+        if (pVariables->rgVariables)
+        {
+            hr = ::SizeTMult(sizeof(BURN_VARIABLE), pVariables->dwMaxVariables, &cbAllocSize);
+            ExitOnRootFailure(hr, "Overflow while calculating size of variable array buffer");
+
+            LPVOID pv = MemReAlloc(pVariables->rgVariables, cbAllocSize, FALSE);
+            ExitOnNull(pv, hr, E_OUTOFMEMORY, "Failed to allocate room for more variables.");
+
+            // Prefast claims it's possible to hit this. Putting the check in just in case.
+            if (pVariables->dwMaxVariables < pVariables->cVariables)
+            {
+                hr = INTSAFE_E_ARITHMETIC_OVERFLOW;
+                ExitOnRootFailure(hr, "Overflow while dealing with variable array buffer allocation");
+            }
+
+            pVariables->rgVariables = (BURN_VARIABLE*)pv;
+            memset(&pVariables->rgVariables[pVariables->cVariables], 0, sizeof(BURN_VARIABLE) * (pVariables->dwMaxVariables - pVariables->cVariables));
+        }
+        else
+        {
+            pVariables->rgVariables = (BURN_VARIABLE*)MemAlloc(sizeof(BURN_VARIABLE) * pVariables->dwMaxVariables, TRUE);
+            ExitOnNull(pVariables->rgVariables, hr, E_OUTOFMEMORY, "Failed to allocate room for variables.");
+        }
+    }
+
+    // move variables
+    if (0 < pVariables->cVariables - iPosition)
+    {
+        memmove(&pVariables->rgVariables[iPosition + 1], &pVariables->rgVariables[iPosition], sizeof(BURN_VARIABLE) * (pVariables->cVariables - iPosition));
+        memset(&pVariables->rgVariables[iPosition], 0, sizeof(BURN_VARIABLE));
+    }
+
+    ++pVariables->cVariables;
+
+    // allocate name
+    hr = StrAllocString(&pVariables->rgVariables[iPosition].sczName, wzVariable, 0);
+    ExitOnFailure(hr, "Failed to copy variable name.");
+
+LExit:
+    return hr;
+}
+
+static HRESULT SetVariableValue(
+    __in BURN_VARIABLES* pVariables,
+    __in_z LPCWSTR wzVariable,
+    __in BURN_VARIANT* pVariant,
+    __in BOOL fLiteral,
+    __in SET_VARIABLE setBuiltin,
+    __in BOOL fLog
+    )
+{
+    HRESULT hr = S_OK;
+    DWORD iVariable = 0;
+
+    ::EnterCriticalSection(&pVariables->csAccess);
+
+    hr = FindVariableIndexByName(pVariables, wzVariable, &iVariable);
+    ExitOnFailure(hr, "Failed to find variable value '%ls'.", wzVariable);
+
+    // Insert element if not found.
+    if (S_FALSE == hr)
+    {
+        hr = InsertVariable(pVariables, wzVariable, iVariable);
+        ExitOnFailure(hr, "Failed to insert variable '%ls'.", wzVariable);
+    }
+    else if (BURN_VARIABLE_INTERNAL_TYPE_NORMAL < pVariables->rgVariables[iVariable].internalType) // built-in variables must be overridden.
+    {
+        if (SET_VARIABLE_OVERRIDE_BUILTIN == setBuiltin ||
+            (SET_VARIABLE_OVERRIDE_PERSISTED_BUILTINS == setBuiltin && pVariables->rgVariables[iVariable].fPersisted) ||
+            SET_VARIABLE_ANY == setBuiltin && BURN_VARIABLE_INTERNAL_TYPE_BUILTIN != pVariables->rgVariables[iVariable].internalType)
+        {
+            hr = S_OK;
+        }
+        else
+        {
+            hr = E_INVALIDARG;
+            ExitOnRootFailure(hr, "Attempt to set built-in variable value: %ls", wzVariable);
+        }
+    }
+    else // must *not* be a built-in variable so caller should not have tried to override it as a built-in.
+    {
+        // Not possible from external callers so just assert.
+        AssertSz(SET_VARIABLE_OVERRIDE_BUILTIN != setBuiltin, "Intent to overwrite non-built-in variable.");
+    }
+
+    // Log value when not overwriting a built-in variable.
+    if (fLog && BURN_VARIABLE_INTERNAL_TYPE_NORMAL == pVariables->rgVariables[iVariable].internalType)
+    {
+        if (pVariables->rgVariables[iVariable].fHidden)
+        {
+            LogStringLine(REPORT_STANDARD, "Setting hidden variable '%ls'", wzVariable);
+        }
+        else
+        {
+            // Assume value isn't encrypted since it's not hidden.
+            switch (pVariant->Type)
+            {
+            case BURN_VARIANT_TYPE_NONE:
+                if (BURN_VARIANT_TYPE_NONE != pVariables->rgVariables[iVariable].Value.Type)
+                {
+                    LogStringLine(REPORT_STANDARD, "Unsetting variable '%ls'", wzVariable, pVariant->sczValue);
+                }
+                break;
+
+            case BURN_VARIANT_TYPE_NUMERIC:
+                LogStringLine(REPORT_STANDARD, "Setting numeric variable '%ls' to value %lld", wzVariable, pVariant->llValue);
+                break;
+
+            case BURN_VARIANT_TYPE_STRING:
+                if (!pVariant->sczValue)
+                {
+                    LogStringLine(REPORT_STANDARD, "Unsetting variable '%ls'", wzVariable, pVariant->sczValue);
+                }
+                else
+                {
+                    LogStringLine(REPORT_STANDARD, "Setting string variable '%ls' to value '%ls'", wzVariable, pVariant->sczValue);
+                }
+                break;
+
+            case BURN_VARIANT_TYPE_VERSION:
+                LogStringLine(REPORT_STANDARD, "Setting version variable '%ls' to value '%hu.%hu.%hu.%hu'", wzVariable, (WORD)(pVariant->qwValue >> 48), (WORD)(pVariant->qwValue >> 32), (WORD)(pVariant->qwValue >> 16), (WORD)(pVariant->qwValue));
+                break;
+
+            default:
+                AssertSz(FALSE, "Unknown variant type.");
+                break;
+            }
+        }
+    }
+
+    // Update variable value.
+    hr = BVariantSetValue(&pVariables->rgVariables[iVariable].Value, pVariant);
+    ExitOnFailure(hr, "Failed to set value of variable: %ls", wzVariable);
+
+    // Update variable literal flag.
+    pVariables->rgVariables[iVariable].fLiteral = fLiteral;
+
+LExit:
+    ::LeaveCriticalSection(&pVariables->csAccess);
+
+    if (FAILED(hr) && fLog)
+    {
+        LogStringLine(REPORT_STANDARD, "Setting variable failed: ID '%ls', HRESULT 0x%x", wzVariable, hr);
+    }
+
+    return hr;
+}
+
+extern "C" typedef NTSTATUS (NTAPI *RTL_GET_VERSION)(_Out_  PRTL_OSVERSIONINFOEXW lpVersionInformation);
+
+static HRESULT InitializeVariableVersionNT(
+    __in DWORD_PTR dwpData,
+    __inout BURN_VARIANT* pValue
+    )
+{
+    HRESULT hr = S_OK;
+    HMODULE ntdll = NULL;
+    RTL_GET_VERSION rtlGetVersion = NULL;
+    RTL_OSVERSIONINFOEXW ovix = { };
+    BURN_VARIANT value = { };
+
+    if (!::GetModuleHandleExW(0, L"ntdll", &ntdll))
+    {
+        ExitWithLastError(hr, "Failed to locate NTDLL.");
+    }
+
+    rtlGetVersion = reinterpret_cast<RTL_GET_VERSION>(::GetProcAddress(ntdll, "RtlGetVersion"));
+    if (NULL == rtlGetVersion)
+    {
+        ExitWithLastError(hr, "Failed to locate RtlGetVersion.");
+    }
+
+    ovix.dwOSVersionInfoSize = sizeof(RTL_OSVERSIONINFOEXW);
+    hr = static_cast<HRESULT>(rtlGetVersion(&ovix));
+    ExitOnFailure(hr, "Failed to get OS info.");
+
+    switch ((OS_INFO_VARIABLE)dwpData)
+    {
+    case OS_INFO_VARIABLE_ServicePackLevel:
+        if (0 != ovix.wServicePackMajor)
+        {
+            value.qwValue = static_cast<DWORD64>(ovix.wServicePackMajor);
+            value.Type = BURN_VARIANT_TYPE_NUMERIC;
+        }
+        break;
+    case OS_INFO_VARIABLE_VersionNT:
+        value.qwValue = MAKEQWORDVERSION(ovix.dwMajorVersion, ovix.dwMinorVersion, 0, 0);
+        value.Type = BURN_VARIANT_TYPE_VERSION;
+        break;
+    case OS_INFO_VARIABLE_VersionNT64:
+        {
+#if !defined(_WIN64)
+            BOOL fIsWow64 = FALSE;
+
+            ProcWow64(::GetCurrentProcess(), &fIsWow64);
+            if (fIsWow64)
+#endif
+            {
+                value.qwValue = MAKEQWORDVERSION(ovix.dwMajorVersion, ovix.dwMinorVersion, 0, 0);
+                value.Type = BURN_VARIANT_TYPE_VERSION;
+            }
+        }
+        break;
+    default:
+        AssertSz(FALSE, "Unknown OS info type.");
+        break;
+    }
+
+    hr = BVariantCopy(&value, pValue);
+    ExitOnFailure(hr, "Failed to set variant value.");
+
+LExit:
+    if (NULL != ntdll)
+    {
+        FreeLibrary(ntdll);
+    }
+
+    return hr;
+}
+
+static HRESULT InitializeVariableOsInfo(
+    __in DWORD_PTR dwpData,
+    __inout BURN_VARIANT* pValue
+    )
+{
+    HRESULT hr = S_OK;
+    OSVERSIONINFOEXW ovix = { };
+    BURN_VARIANT value = { };
+
+    ovix.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXW);
+    if (!::GetVersionExW((LPOSVERSIONINFOW)&ovix))
+    {
+        ExitWithLastError(hr, "Failed to get OS info.");
+    }
+
+    switch ((OS_INFO_VARIABLE)dwpData)
+    {
+    case OS_INFO_VARIABLE_NTProductType:
+        value.llValue = ovix.wProductType;
+        value.Type = BURN_VARIANT_TYPE_NUMERIC;
+        break;
+    case OS_INFO_VARIABLE_NTSuiteBackOffice:
+        value.llValue = VER_SUITE_BACKOFFICE & ovix.wSuiteMask ? 1 : 0;
+        value.Type = BURN_VARIANT_TYPE_NUMERIC;
+        break;
+    case OS_INFO_VARIABLE_NTSuiteDataCenter:
+        value.llValue = VER_SUITE_DATACENTER & ovix.wSuiteMask ? 1 : 0;
+        value.Type = BURN_VARIANT_TYPE_NUMERIC;
+        break;
+    case OS_INFO_VARIABLE_NTSuiteEnterprise:
+        value.llValue = VER_SUITE_ENTERPRISE & ovix.wSuiteMask ? 1 : 0;
+        value.Type = BURN_VARIANT_TYPE_NUMERIC;
+        break;
+    case OS_INFO_VARIABLE_NTSuitePersonal:
+        value.llValue = VER_SUITE_PERSONAL & ovix.wSuiteMask ? 1 : 0;
+        value.Type = BURN_VARIANT_TYPE_NUMERIC;
+        break;
+    case OS_INFO_VARIABLE_NTSuiteSmallBusiness:
+        value.llValue = VER_SUITE_SMALLBUSINESS & ovix.wSuiteMask ? 1 : 0;
+        value.Type = BURN_VARIANT_TYPE_NUMERIC;
+        break;
+    case OS_INFO_VARIABLE_NTSuiteSmallBusinessRestricted:
+        value.llValue = VER_SUITE_SMALLBUSINESS_RESTRICTED & ovix.wSuiteMask ? 1 : 0;
+        value.Type = BURN_VARIANT_TYPE_NUMERIC;
+        break;
+    case OS_INFO_VARIABLE_NTSuiteWebServer:
+        value.llValue = VER_SUITE_BLADE & ovix.wSuiteMask ? 1 : 0;
+        value.Type = BURN_VARIANT_TYPE_NUMERIC;
+        break;
+    case OS_INFO_VARIABLE_CompatibilityMode:
+        {
+            DWORDLONG dwlConditionMask = 0;
+            VER_SET_CONDITION(dwlConditionMask, VER_MAJORVERSION, VER_EQUAL);
+            VER_SET_CONDITION(dwlConditionMask, VER_MINORVERSION, VER_EQUAL);
+            VER_SET_CONDITION(dwlConditionMask, VER_SERVICEPACKMAJOR, VER_EQUAL);
+            VER_SET_CONDITION(dwlConditionMask, VER_SERVICEPACKMINOR, VER_EQUAL);
+
+            value.llValue = ::VerifyVersionInfoW(&ovix, VER_MAJORVERSION | VER_MINORVERSION | VER_SERVICEPACKMAJOR | VER_SERVICEPACKMINOR, dwlConditionMask);
+            value.Type = BURN_VARIANT_TYPE_NUMERIC;
+        }
+        break;
+    case OS_INFO_VARIABLE_TerminalServer:
+        value.llValue = (VER_SUITE_TERMINAL == (ovix.wSuiteMask & VER_SUITE_TERMINAL)) && (VER_SUITE_SINGLEUSERTS != (ovix.wSuiteMask & VER_SUITE_SINGLEUSERTS)) ? 1 : 0;
+        value.Type = BURN_VARIANT_TYPE_NUMERIC;
+        break;
+    default:
+        AssertSz(FALSE, "Unknown OS info type.");
+        break;
+    }
+
+    hr = BVariantCopy(&value, pValue);
+    ExitOnFailure(hr, "Failed to set variant value.");
+
+LExit:
+    return hr;
+}
+
+static HRESULT InitializeVariableSystemInfo(
+    __in DWORD_PTR dwpData,
+    __inout BURN_VARIANT* pValue
+    )
+{
+    HRESULT hr = S_OK;
+    SYSTEM_INFO si = { };
+    BURN_VARIANT value = { };
+
+    ::GetNativeSystemInfo(&si);
+
+    switch ((OS_INFO_VARIABLE)dwpData)
+    {
+    case OS_INFO_VARIABLE_ProcessorArchitecture:
+        value.llValue = si.wProcessorArchitecture;
+        value.Type = BURN_VARIANT_TYPE_NUMERIC;
+        break;
+    default:
+        AssertSz(FALSE, "Unknown OS info type.");
+        break;
+    }
+
+    hr = BVariantCopy(&value, pValue);
+    ExitOnFailure(hr, "Failed to set variant value.");
+
+LExit:
+    return hr;
+}
+
+static HRESULT InitializeVariableComputerName(
+    __in DWORD_PTR dwpData,
+    __inout BURN_VARIANT* pValue
+    )
+{
+    UNREFERENCED_PARAMETER(dwpData);
+
+    HRESULT hr = S_OK;
+    WCHAR wzComputerName[MAX_COMPUTERNAME_LENGTH + 1] = { };
+    DWORD cchComputerName = countof(wzComputerName);
+
+    // get computer name
+    if (!::GetComputerNameW(wzComputerName, &cchComputerName))
+    {
+        ExitWithLastError(hr, "Failed to get computer name.");
+    }
+
+    // set value
+    hr = BVariantSetString(pValue, wzComputerName, 0);
+    ExitOnFailure(hr, "Failed to set variant value.");
+
+LExit:
+    return hr;
+}
+
+static HRESULT InitializeVariableVersionMsi(
+    __in DWORD_PTR dwpData,
+    __inout BURN_VARIANT* pValue
+    )
+{
+    UNREFERENCED_PARAMETER(dwpData);
+
+    HRESULT hr = S_OK;
+    DLLGETVERSIONPROC pfnMsiDllGetVersion = NULL;
+    DLLVERSIONINFO msiVersionInfo = { };
+
+    // get DllGetVersion proc address
+    pfnMsiDllGetVersion = (DLLGETVERSIONPROC)::GetProcAddress(::GetModuleHandleW(L"msi"), "DllGetVersion");
+    ExitOnNullWithLastError(pfnMsiDllGetVersion, hr, "Failed to find DllGetVersion entry point in msi.dll.");
+
+    // get msi.dll version info
+    msiVersionInfo.cbSize = sizeof(DLLVERSIONINFO);
+    hr = pfnMsiDllGetVersion(&msiVersionInfo);
+    ExitOnFailure(hr, "Failed to get msi.dll version info.");
+
+    hr = BVariantSetVersion(pValue, MAKEQWORDVERSION(msiVersionInfo.dwMajorVersion, msiVersionInfo.dwMinorVersion, 0, 0));
+    ExitOnFailure(hr, "Failed to set variant value.");
+
+LExit:
+    return hr;
+}
+
+static HRESULT InitializeVariableCsidlFolder(
+    __in DWORD_PTR dwpData,
+    __inout BURN_VARIANT* pValue
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR sczPath = NULL;
+    int nFolder = (int)dwpData;
+
+    // get folder path
+    hr = ShelGetFolder(&sczPath, nFolder);
+    ExitOnRootFailure(hr, "Failed to get shell folder.");
+
+    // set value
+    hr = BVariantSetString(pValue, sczPath, 0);
+    ExitOnFailure(hr, "Failed to set variant value.");
+
+LExit:
+    ReleaseStr(sczPath);
+
+    return hr;
+}
+
+static HRESULT InitializeVariableTempFolder(
+    __in DWORD_PTR dwpData,
+    __inout BURN_VARIANT* pValue
+    )
+{
+    UNREFERENCED_PARAMETER(dwpData);
+
+    HRESULT hr = S_OK;
+    WCHAR wzPath[MAX_PATH] = { };
+
+    // get volume path name
+    if (!::GetTempPathW(MAX_PATH, wzPath))
+    {
+        ExitWithLastError(hr, "Failed to get temp path.");
+    }
+
+    // set value
+    hr = BVariantSetString(pValue, wzPath, 0);
+    ExitOnFailure(hr, "Failed to set variant value.");
+
+LExit:
+    return hr;
+}
+
+static HRESULT InitializeVariableSystemFolder(
+    __in DWORD_PTR dwpData,
+    __inout BURN_VARIANT* pValue
+    )
+{
+    HRESULT hr = S_OK;
+    BOOL f64 = (BOOL)dwpData;
+    WCHAR wzSystemFolder[MAX_PATH] = { };
+
+#if !defined(_WIN64)
+    BOOL fIsWow64 = FALSE;
+    ProcWow64(::GetCurrentProcess(), &fIsWow64);
+
+    if (fIsWow64)
+    {
+        if (f64)
+        {
+            if (!::GetSystemDirectoryW(wzSystemFolder, countof(wzSystemFolder)))
+            {
+                ExitWithLastError(hr, "Failed to get 64-bit system folder.");
+            }
+        }
+        else
+        {
+            if (!::GetSystemWow64DirectoryW(wzSystemFolder, countof(wzSystemFolder)))
+            {
+                ExitWithLastError(hr, "Failed to get 32-bit system folder.");
+            }
+        }
+    }
+    else
+    {
+        if (!f64)
+        {
+            if (!::GetSystemDirectoryW(wzSystemFolder, countof(wzSystemFolder)))
+            {
+                ExitWithLastError(hr, "Failed to get 32-bit system folder.");
+            }
+        }
+    }
+#else
+    if (f64)
+    {
+        if (!::GetSystemDirectoryW(wzSystemFolder, countof(wzSystemFolder)))
+        {
+            ExitWithLastError(hr, "Failed to get 64-bit system folder.");
+        }
+    }
+    else
+    {
+        if (!::GetSystemWow64DirectoryW(wzSystemFolder, countof(wzSystemFolder)))
+        {
+            ExitWithLastError(hr, "Failed to get 32-bit system folder.");
+        }
+    }
+#endif
+
+    if (*wzSystemFolder)
+    {
+        hr = PathFixedBackslashTerminate(wzSystemFolder, countof(wzSystemFolder));
+        ExitOnFailure(hr, "Failed to backslash terminate system folder.");
+    }
+
+    // set value
+    hr = BVariantSetString(pValue, wzSystemFolder, 0);
+    ExitOnFailure(hr, "Failed to set system folder variant value.");
+
+LExit:
+    return hr;
+}
+
+static HRESULT InitializeVariableWindowsVolumeFolder(
+    __in DWORD_PTR dwpData,
+    __inout BURN_VARIANT* pValue
+    )
+{
+    UNREFERENCED_PARAMETER(dwpData);
+
+    HRESULT hr = S_OK;
+    WCHAR wzWindowsPath[MAX_PATH] = { };
+    WCHAR wzVolumePath[MAX_PATH] = { };
+
+    // get windows directory
+    if (!::GetWindowsDirectoryW(wzWindowsPath, countof(wzWindowsPath)))
+    {
+        ExitWithLastError(hr, "Failed to get windows directory.");
+    }
+
+    // get volume path name
+    if (!::GetVolumePathNameW(wzWindowsPath, wzVolumePath, MAX_PATH))
+    {
+        ExitWithLastError(hr, "Failed to get volume path name.");
+    }
+
+    // set value
+    hr = BVariantSetString(pValue, wzVolumePath, 0);
+    ExitOnFailure(hr, "Failed to set variant value.");
+
+LExit:
+    return hr;
+}
+
+static HRESULT InitializeVariablePrivileged(
+    __in DWORD_PTR dwpData,
+    __inout BURN_VARIANT* pValue
+    )
+{
+    UNREFERENCED_PARAMETER(dwpData);
+
+    HRESULT hr = S_OK;
+    BOOL fPrivileged = FALSE;
+
+    // check if process could run privileged.
+    hr = OsCouldRunPrivileged(&fPrivileged);
+    ExitOnFailure(hr, "Failed to check if process could run privileged.");
+
+    // set value
+    hr = BVariantSetNumeric(pValue, fPrivileged);
+    ExitOnFailure(hr, "Failed to set variant value.");
+
+LExit:
+    return hr;
+}
+
+static HRESULT InitializeVariableRebootPending(
+    __in DWORD_PTR dwpData,
+    __inout BURN_VARIANT* pValue
+    )
+{
+    UNREFERENCED_PARAMETER(dwpData);
+
+    HRESULT hr = S_OK;
+    BOOL fRebootPending = FALSE;
+    BOOL fComInitialized = FALSE;
+
+    // Do a best effort to ask WU if a reboot is required. If anything goes
+    // wrong then let's pretend a reboot is not required.
+    hr = ::CoInitialize(NULL);
+    if (SUCCEEDED(hr) || RPC_E_CHANGED_MODE == hr)
+    {
+        fComInitialized = TRUE;
+
+        hr = WuaRestartRequired(&fRebootPending);
+        if (FAILED(hr))
+        {
+            fRebootPending = FALSE;
+            hr = S_OK;
+        }
+    }
+
+    hr = BVariantSetNumeric(pValue, fRebootPending);
+    ExitOnFailure(hr, "Failed to set reboot pending variant value.");
+
+LExit:
+    if (fComInitialized)
+    {
+        ::CoUninitialize();
+    }
+
+    return hr;
+}
+
+static HRESULT InitializeSystemLanguageID(
+    __in DWORD_PTR dwpData,
+    __inout BURN_VARIANT* pValue
+    )
+{
+    UNREFERENCED_PARAMETER(dwpData);
+
+    HRESULT hr = S_OK;
+    LANGID langid = ::GetSystemDefaultLangID();
+
+    hr = BVariantSetNumeric(pValue, langid);
+    ExitOnFailure(hr, "Failed to set variant value.");
+
+LExit:
+    return hr;
+}
+
+static HRESULT InitializeUserUILanguageID(
+    __in DWORD_PTR dwpData,
+    __inout BURN_VARIANT* pValue
+    )
+{
+    UNREFERENCED_PARAMETER(dwpData);
+
+    HRESULT hr = S_OK;
+    LANGID langid = ::GetUserDefaultUILanguage();
+
+    hr = BVariantSetNumeric(pValue, langid);
+    ExitOnFailure(hr, "Failed to set variant value.");
+
+LExit:
+    return hr;
+}
+
+static HRESULT InitializeUserLanguageID(
+    __in DWORD_PTR dwpData,
+    __inout BURN_VARIANT* pValue
+    )
+{
+    UNREFERENCED_PARAMETER(dwpData);
+
+    HRESULT hr = S_OK;
+    LANGID langid = ::GetUserDefaultLangID();
+
+    hr = BVariantSetNumeric(pValue, langid);
+    ExitOnFailure(hr, "Failed to set variant value.");
+
+LExit:
+    return hr;
+}
+
+static HRESULT InitializeVariableString(
+    __in DWORD_PTR dwpData,
+    __inout BURN_VARIANT* pValue
+    )
+{
+    HRESULT hr = S_OK;
+    LPCWSTR wzValue = (LPCWSTR)dwpData;
+
+    // set value
+    hr = BVariantSetString(pValue, wzValue, 0);
+    ExitOnFailure(hr, "Failed to set variant value.");
+
+LExit:
+    return hr;
+}
+
+static HRESULT InitializeVariableNumeric(
+    __in DWORD_PTR dwpData,
+    __inout BURN_VARIANT* pValue
+    )
+{
+    HRESULT hr = S_OK;
+    LONGLONG llValue = (LONGLONG)dwpData;
+
+    // set value
+    hr = BVariantSetNumeric(pValue, llValue);
+    ExitOnFailure(hr, "Failed to set variant value.");
+
+LExit:
+    return hr;
+}
+
+static HRESULT InitializeVariableRegistryFolder(
+    __in DWORD_PTR dwpData,
+    __inout BURN_VARIANT* pValue
+    )
+{
+    HRESULT hr = S_OK;
+    int nFolder = (int)dwpData;
+    LPWSTR sczPath = NULL;
+
+#if !defined(_WIN64)
+    BOOL fIsWow64 = FALSE;
+
+    ProcWow64(::GetCurrentProcess(), &fIsWow64);
+    if (!fIsWow64) // on 32-bit machines, variables aren't set
+    {
+        ExitFunction();
+    }
+#endif
+
+    hr = Get64bitFolderFromRegistry(nFolder, &sczPath);
+    ExitOnFailure(hr, "Failed to get 64-bit folder.");
+
+    // set value
+    hr = BVariantSetString(pValue, sczPath, 0);
+    ExitOnFailure(hr, "Failed to set variant value.");
+
+LExit:
+    ReleaseStr(sczPath);
+
+    return hr;
+}
+
+static HRESULT InitializeVariable6432Folder(
+        __in DWORD_PTR dwpData,
+    __inout BURN_VARIANT* pValue
+    )
+{
+    HRESULT hr = S_OK;
+    int nFolder = (int)dwpData;
+    LPWSTR sczPath = NULL;
+
+#if !defined(_WIN64)
+    BOOL fIsWow64 = FALSE;
+
+    // If 32-bit use shell-folder.
+    ProcWow64(::GetCurrentProcess(), &fIsWow64);
+    if (!fIsWow64)
+    {
+        hr = ShelGetFolder(&sczPath, nFolder);
+        ExitOnRootFailure(hr, "Failed to get shell folder.");
+    }
+    else
+#endif
+    {
+        hr = Get64bitFolderFromRegistry(nFolder, &sczPath);
+        ExitOnFailure(hr, "Failed to get 64-bit folder.");
+    }
+
+    // set value
+    hr = BVariantSetString(pValue, sczPath, 0);
+    ExitOnFailure(hr, "Failed to set variant value.");
+
+LExit:
+    ReleaseStr(sczPath);
+
+    return hr;
+}
+
+// Get the date in the same format as Windows Installer.
+static HRESULT InitializeVariableDate(
+    __in DWORD_PTR /*dwpData*/,
+    __inout BURN_VARIANT* pValue
+    )
+{
+    HRESULT hr = S_OK;
+    SYSTEMTIME systime = { };
+    LPWSTR sczDate = NULL;
+    int cchDate = 0;
+
+    ::GetSystemTime(&systime);
+
+    cchDate = ::GetDateFormatW(LOCALE_USER_DEFAULT, DATE_SHORTDATE, &systime, NULL, NULL, cchDate);
+    if (!cchDate)
+    {
+        ExitOnLastError(hr, "Failed to get the required buffer length for the Date.");
+    }
+
+    hr = StrAlloc(&sczDate, cchDate);
+    ExitOnFailure(hr, "Failed to allocate the buffer for the Date.");
+
+    if (!::GetDateFormatW(LOCALE_USER_DEFAULT, DATE_SHORTDATE, &systime, NULL, sczDate, cchDate))
+    {
+        ExitOnLastError(hr, "Failed to get the Date.");
+    }
+
+    // set value
+    hr = BVariantSetString(pValue, sczDate, cchDate);
+    ExitOnFailure(hr, "Failed to set variant value.");
+
+LExit:
+    ReleaseStr(sczDate);
+
+    return hr;
+}
+
+static HRESULT InitializeVariableInstallerName(
+    __in DWORD_PTR /*dwpData*/,
+    __inout BURN_VARIANT* pValue
+    )
+{
+    HRESULT hr = S_OK;
+
+    // set value
+    hr = BVariantSetString(pValue, L"WiX Burn", 0);
+    ExitOnFailure(hr, "Failed to set variant value.");
+
+LExit:
+    return hr;
+}
+
+static HRESULT InitializeVariableInstallerVersion(
+    __in DWORD_PTR /*dwpData*/,
+    __inout BURN_VARIANT* pValue
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR sczVersion = NULL;
+
+    hr = StrAllocStringAnsi(&sczVersion, szVerMajorMinorBuild, 0, CP_ACP);
+    ExitOnFailure(hr, "Failed to copy the engine version.");
+
+    // set value
+    hr = BVariantSetString(pValue, sczVersion, 0);
+    ExitOnFailure(hr, "Failed to set variant value.");
+
+LExit:
+    ReleaseStr(sczVersion);
+
+    return hr;
+}
+
+static HRESULT InitializeVariableVersion(
+    __in DWORD_PTR dwpData,
+    __inout BURN_VARIANT* pValue
+    )
+{
+    HRESULT hr = S_OK;
+
+    // set value
+    hr = BVariantSetVersion(pValue, static_cast<DWORD64>(dwpData));
+    ExitOnFailure(hr, "Failed to set variant value.");
+
+LExit:
+    return hr;
+}
+
+// Get the current user the same as Windows Installer.
+static HRESULT InitializeVariableLogonUser(
+    __in DWORD_PTR /*dwpData*/,
+    __inout BURN_VARIANT* pValue
+    )
+{
+    HRESULT hr = S_OK;
+    WCHAR wzUserName[UNLEN + 1];
+    DWORD cchUserName = countof(wzUserName);
+
+    if (!::GetUserNameW(wzUserName, &cchUserName))
+    {
+        ExitOnLastError(hr, "Failed to get the user name.");
+    }
+
+    // set value
+    hr = BVariantSetString(pValue, wzUserName, 0);
+    ExitOnFailure(hr, "Failed to set variant value.");
+
+LExit:
+    return hr;
+}
+
+static HRESULT Get64bitFolderFromRegistry(
+    __in int nFolder,
+    __deref_out_z LPWSTR* psczPath
+    )
+{
+    HRESULT hr = S_OK;
+    HKEY hkFolders = NULL;
+
+    AssertSz(CSIDL_PROGRAM_FILES == nFolder || CSIDL_PROGRAM_FILES_COMMON == nFolder, "Unknown folder CSIDL.");
+    LPCWSTR wzFolderValue = CSIDL_PROGRAM_FILES_COMMON == nFolder ? L"CommonFilesDir" : L"ProgramFilesDir";
+
+    hr = RegOpen(HKEY_LOCAL_MACHINE, L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion", KEY_READ | KEY_WOW64_64KEY, &hkFolders);
+    ExitOnFailure(hr, "Failed to open Windows folder key.");
+
+    hr = RegReadString(hkFolders, wzFolderValue, psczPath);
+    ExitOnFailure(hr, "Failed to read folder path for '%ls'.", wzFolderValue);
+
+    hr = PathBackslashTerminate(psczPath);
+    ExitOnFailure(hr, "Failed to ensure path was backslash terminated.");
+
+LExit:
+    ReleaseRegKey(hkFolders);
+
+    return hr;
+}
+
diff --git a/src/engine/variable.h b/src/engine/variable.h
new file mode 100644
index 00000000..c48e0160
--- /dev/null
+++ b/src/engine/variable.h
@@ -0,0 +1,190 @@
+#pragma once
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+
+// constants
+
+const LPCWSTR VARIABLE_DATE = L"Date";
+const LPCWSTR VARIABLE_LOGONUSER = L"LogonUser";
+const LPCWSTR VARIABLE_INSTALLERNAME = L"InstallerName";
+const LPCWSTR VARIABLE_INSTALLERVERSION = L"InstallerVersion";
+
+
+// typedefs
+
+typedef HRESULT (*PFN_INITIALIZEVARIABLE)(
+    __in DWORD_PTR dwpData,
+    __inout BURN_VARIANT* pValue
+    );
+
+
+// constants
+
+enum BURN_VARIABLE_INTERNAL_TYPE
+{
+    BURN_VARIABLE_INTERNAL_TYPE_NORMAL, // the BA can set this variable.
+    BURN_VARIABLE_INTERNAL_TYPE_OVERRIDABLE_BUILTIN, // the BA can't set this variable, but the unelevated process can serialize it to the elevated process.
+    BURN_VARIABLE_INTERNAL_TYPE_BUILTIN, // the BA can't set this variable, and the unelevated process can't serialize it to the elevated process.
+};
+
+
+// structs
+
+typedef struct _BURN_VARIABLE
+{
+    LPWSTR sczName;
+    BURN_VARIANT Value;
+    BOOL fHidden;    
+    BOOL fLiteral; // if fLiteral, then when formatting this variable its value should be used as is (don't continue recursively formatting).
+    BOOL fPersisted;
+
+    // used for late initialization of built-in variables
+    BURN_VARIABLE_INTERNAL_TYPE internalType;
+    PFN_INITIALIZEVARIABLE pfnInitialize;
+    DWORD_PTR dwpInitializeData;
+} BURN_VARIABLE;
+
+typedef struct _BURN_VARIABLES
+{
+    CRITICAL_SECTION csAccess;
+    DWORD dwMaxVariables;
+    DWORD cVariables;
+    BURN_VARIABLE* rgVariables;
+} BURN_VARIABLES;
+
+
+// function declarations
+
+HRESULT VariableInitialize(
+    __in BURN_VARIABLES* pVariables
+    );
+HRESULT VariablesParseFromXml(
+    __in BURN_VARIABLES* pVariables,
+    __in IXMLDOMNode* pixnBundle
+    );
+void VariablesUninitialize(
+    __in BURN_VARIABLES* pVariables
+    );
+void VariablesDump(
+    __in BURN_VARIABLES* pVariables
+    );
+HRESULT VariableGetNumeric(
+    __in BURN_VARIABLES* pVariables,
+    __in_z LPCWSTR wzVariable,
+    __out LONGLONG* pllValue
+    );
+HRESULT VariableGetString(
+    __in BURN_VARIABLES* pVariables,
+    __in_z LPCWSTR wzVariable,
+    __out_z LPWSTR* psczValue
+    );
+HRESULT VariableGetVersion(
+    __in BURN_VARIABLES* pVariables,
+    __in_z LPCWSTR wzVariable,
+    __in DWORD64* pqwValue
+    );
+HRESULT VariableGetVariant(
+    __in BURN_VARIABLES* pVariables,
+    __in_z LPCWSTR wzVariable,
+    __in BURN_VARIANT* pValue
+    );
+HRESULT VariableGetFormatted(
+    __in BURN_VARIABLES* pVariables,
+    __in_z LPCWSTR wzVariable,
+    __out_z LPWSTR* psczValue
+    );
+HRESULT VariableSetNumeric(
+    __in BURN_VARIABLES* pVariables,
+    __in_z LPCWSTR wzVariable,
+    __in LONGLONG llValue,
+    __in BOOL fOverwriteBuiltIn
+    );
+HRESULT VariableSetLiteralString(
+    __in BURN_VARIABLES* pVariables,
+    __in_z LPCWSTR wzVariable,
+    __in_z_opt LPCWSTR wzValue,
+    __in BOOL fOverwriteBuiltIn
+    );
+HRESULT VariableSetString(
+    __in BURN_VARIABLES* pVariables,
+    __in_z LPCWSTR wzVariable,
+    __in_z_opt LPCWSTR wzValue,
+    __in BOOL fOverwriteBuiltIn
+    );
+HRESULT VariableSetVersion(
+    __in BURN_VARIABLES* pVariables,
+    __in_z LPCWSTR wzVariable,
+    __in DWORD64 qwValue,
+    __in BOOL fOverwriteBuiltIn
+    );
+HRESULT VariableSetLiteralVariant(
+    __in BURN_VARIABLES* pVariables,
+    __in_z LPCWSTR wzVariable,
+    __in BURN_VARIANT* pVariant
+    );
+HRESULT VariableFormatString(
+    __in BURN_VARIABLES* pVariables,
+    __in_z LPCWSTR wzIn,
+    __out_z_opt LPWSTR* psczOut,
+    __out_opt DWORD* pcchOut
+    );
+HRESULT VariableFormatStringObfuscated(
+    __in BURN_VARIABLES* pVariables,
+    __in_z LPCWSTR wzIn,
+    __out_z_opt LPWSTR* psczOut,
+    __out_opt DWORD* pcchOut
+    );
+HRESULT VariableEscapeString(
+    __in_z LPCWSTR wzIn,
+    __out_z LPWSTR* psczOut
+    );
+HRESULT VariableSerialize(
+    __in BURN_VARIABLES* pVariables,
+    __in BOOL fPersisting,
+    __inout BYTE** ppbBuffer,
+    __inout SIZE_T* piBuffer
+    );
+HRESULT VariableDeserialize(
+    __in BURN_VARIABLES* pVariables,
+    __in BOOL fWasPersisted,
+    __in_bcount(cbBuffer) BYTE* pbBuffer,
+    __in SIZE_T cbBuffer,
+    __inout SIZE_T* piBuffer
+    );
+HRESULT VariableStrAlloc(
+    __in BOOL fZeroOnRealloc,
+    __deref_out_ecount_part(cch, 0) LPWSTR* ppwz,
+    __in DWORD_PTR cch
+    );
+HRESULT VariableStrAllocString(
+    __in BOOL fZeroOnRealloc,
+    __deref_out_ecount_z(cchSource + 1) LPWSTR* ppwz,
+    __in_z LPCWSTR wzSource,
+    __in DWORD_PTR cchSource
+    );
+HRESULT VariableStrAllocConcat(
+    __in BOOL fZeroOnRealloc,
+    __deref_out_z LPWSTR* ppwz,
+    __in_z LPCWSTR wzSource,
+    __in DWORD_PTR cchSource
+    );
+HRESULT __cdecl VariableStrAllocFormatted(
+    __in BOOL fZeroOnRealloc,
+    __deref_out_z LPWSTR* ppwz,
+    __in __format_string LPCWSTR wzFormat,
+    ...
+    );
+HRESULT VariableIsHidden(
+    __in BURN_VARIABLES* pVariables,
+    __in_z LPCWSTR wzVariable,
+    __out BOOL* pfHidden
+    );
+
+#if defined(__cplusplus)
+}
+#endif
diff --git a/src/engine/variant.cpp b/src/engine/variant.cpp
new file mode 100644
index 00000000..2a9f08ed
--- /dev/null
+++ b/src/engine/variant.cpp
@@ -0,0 +1,601 @@
+// 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.
+
+#include "precomp.h"
+
+#define VARIANT_ENCRYPTION_SCOPE CRYPTPROTECTMEMORY_SAME_PROCESS
+
+// internal function declarations
+
+static HRESULT BVariantEncryptNumeric(
+    __in BURN_VARIANT* pVariant,
+    __in BOOL fEncrypt
+    );
+
+static HRESULT BVariantEncryptString(
+    __in BURN_VARIANT* pVariant,
+    __in BOOL fEncrypt
+    );
+
+static HRESULT BVariantEncryptVersion(
+    __in BURN_VARIANT* pVariant,
+    __in BOOL fEncrypt
+    );
+
+static HRESULT BVariantRetrieveDecryptedNumeric(
+    __in BURN_VARIANT* pVariant,
+    __out LONGLONG* pllValue
+    );
+
+static HRESULT BVariantRetrieveDecryptedString(
+    __in BURN_VARIANT* pVariant,
+    __out LPWSTR* psczValue
+    );
+
+static HRESULT BVariantRetrieveDecryptedVersion(
+    __in BURN_VARIANT* pVariant,
+    __out DWORD64* pqwValue
+    );
+
+// function definitions
+
+extern "C" void BVariantUninitialize(
+    __in BURN_VARIANT* pVariant
+    )
+{
+    if (BURN_VARIANT_TYPE_STRING == pVariant->Type)
+    {
+        StrSecureZeroFreeString(pVariant->sczValue);
+    }
+    SecureZeroMemory(pVariant, sizeof(BURN_VARIANT));
+}
+
+// The contents of pllValue may be sensitive, should keep encrypted and SecureZeroMemory.
+extern "C" HRESULT BVariantGetNumeric(
+    __in BURN_VARIANT* pVariant,
+    __out LONGLONG* pllValue
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR sczValue = NULL;
+
+    switch (pVariant->Type)
+    {
+    case BURN_VARIANT_TYPE_NUMERIC:
+        BVariantRetrieveDecryptedNumeric(pVariant, pllValue);
+        break;
+    case BURN_VARIANT_TYPE_STRING:
+        hr = BVariantRetrieveDecryptedString(pVariant, &sczValue);
+        if (SUCCEEDED(hr))
+        {
+            hr = StrStringToInt64(sczValue, 0, pllValue);
+            if (FAILED(hr))
+            {
+                hr = DISP_E_TYPEMISMATCH;
+            }
+        }
+        StrSecureZeroFreeString(sczValue);
+        break;
+    case BURN_VARIANT_TYPE_VERSION:
+        BVariantRetrieveDecryptedVersion(pVariant, (DWORD64*)pllValue);
+        break;
+    default:
+        hr = E_INVALIDARG;
+        break;
+    }
+
+    return hr;
+}
+
+// The contents of psczValue may be sensitive, should keep encrypted and SecureZeroFree.
+extern "C" HRESULT BVariantGetString(
+    __in BURN_VARIANT* pVariant,
+    __out_z LPWSTR* psczValue
+    )
+{
+    HRESULT hr = S_OK;
+    LONGLONG llValue = 0;
+    DWORD64 qwValue = 0;
+
+    switch (pVariant->Type)
+    {
+    case BURN_VARIANT_TYPE_NUMERIC:
+        hr = BVariantRetrieveDecryptedNumeric(pVariant, &llValue);
+        if (SUCCEEDED(hr))
+        {
+            hr = StrAllocFormattedSecure(psczValue, L"%I64d", llValue);
+            ExitOnFailure(hr, "Failed to convert int64 to string.");
+        }
+        SecureZeroMemory(&llValue, sizeof(llValue));
+        break;
+    case BURN_VARIANT_TYPE_STRING:
+        hr = BVariantRetrieveDecryptedString(pVariant, psczValue);
+        break;
+    case BURN_VARIANT_TYPE_VERSION:
+        hr = BVariantRetrieveDecryptedVersion(pVariant, &qwValue);
+        if (SUCCEEDED(hr))
+        {
+            hr = StrAllocFormattedSecure(psczValue, L"%hu.%hu.%hu.%hu",
+                (WORD)(qwValue >> 48),
+                (WORD)(qwValue >> 32),
+                (WORD)(qwValue >> 16),
+                (WORD)qwValue);
+            ExitOnFailure(hr, "Failed to convert version to string.");
+        }
+        SecureZeroMemory(&qwValue, sizeof(qwValue));
+        break;
+    default:
+        hr = E_INVALIDARG;
+        break;
+    }
+
+LExit:
+    return hr;
+}
+
+// The contents of pqwValue may be sensitive, should keep encrypted and SecureZeroMemory.
+extern "C" HRESULT BVariantGetVersion(
+    __in BURN_VARIANT* pVariant,
+    __out DWORD64* pqwValue
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR sczValue = NULL;
+
+    switch (pVariant->Type)
+    {
+    case BURN_VARIANT_TYPE_NUMERIC:
+        BVariantRetrieveDecryptedNumeric(pVariant, (LONGLONG*)pqwValue);
+        break;
+    case BURN_VARIANT_TYPE_STRING:
+        hr = BVariantRetrieveDecryptedString(pVariant, &sczValue);
+        if (SUCCEEDED(hr))
+        {
+            hr = FileVersionFromStringEx(sczValue, 0, pqwValue);
+            if (FAILED(hr))
+            {
+                hr = DISP_E_TYPEMISMATCH;
+            }
+        }
+        StrSecureZeroFreeString(sczValue);
+        break;
+    case BURN_VARIANT_TYPE_VERSION:
+        BVariantRetrieveDecryptedVersion(pVariant, pqwValue);
+        break;
+    default:
+        hr = E_INVALIDARG;
+        break;
+    }
+
+    return hr;
+}
+
+extern "C" HRESULT BVariantSetNumeric(
+    __in BURN_VARIANT* pVariant,
+    __in LONGLONG llValue
+    )
+{
+    HRESULT hr = S_OK;
+    BOOL fEncryptValue = pVariant->fEncryptValue;
+
+    if (BURN_VARIANT_TYPE_STRING == pVariant->Type)
+    {
+        StrSecureZeroFreeString(pVariant->sczValue);
+    }
+    memset(pVariant, 0, sizeof(BURN_VARIANT));
+    pVariant->llValue = llValue;
+    pVariant->Type = BURN_VARIANT_TYPE_NUMERIC;
+    BVariantSetEncryption(pVariant, fEncryptValue);
+
+    return hr;
+}
+
+extern "C" HRESULT BVariantSetString(
+    __in BURN_VARIANT* pVariant,
+    __in_z_opt LPCWSTR wzValue,
+    __in DWORD_PTR cchValue
+    )
+{
+    HRESULT hr = S_OK;
+    BOOL fEncryptValue = pVariant->fEncryptValue;
+
+    if (!wzValue) // if we're nulling out the string, make the variable NONE.
+    {
+        BVariantUninitialize(pVariant);
+    }
+    else // assign the value.
+    {
+        if (BURN_VARIANT_TYPE_STRING != pVariant->Type)
+        {
+            memset(pVariant, 0, sizeof(BURN_VARIANT));
+        }
+        else
+        {
+            // We're about to copy an unencrypted value.
+            pVariant->fEncryptValue = FALSE;
+        }
+
+        hr = StrAllocStringSecure(&pVariant->sczValue, wzValue, cchValue);
+        ExitOnFailure(hr, "Failed to copy string.");
+
+        pVariant->Type = BURN_VARIANT_TYPE_STRING;
+    }
+
+LExit:
+    BVariantSetEncryption(pVariant, fEncryptValue);
+    return hr;
+}
+
+extern "C" HRESULT BVariantSetVersion(
+    __in BURN_VARIANT* pVariant,
+    __in DWORD64 qwValue
+    )
+{
+    HRESULT hr = S_OK;
+    BOOL fEncryptValue = pVariant->fEncryptValue;
+
+    if (BURN_VARIANT_TYPE_STRING == pVariant->Type)
+    {
+        StrSecureZeroFreeString(pVariant->sczValue);
+    }
+    memset(pVariant, 0, sizeof(BURN_VARIANT));
+    pVariant->qwValue = qwValue;
+    pVariant->Type = BURN_VARIANT_TYPE_VERSION;
+    BVariantSetEncryption(pVariant, fEncryptValue);
+
+    return hr;
+}
+
+extern "C" HRESULT BVariantSetValue(
+    __in BURN_VARIANT* pVariant,
+    __in BURN_VARIANT* pValue
+    )
+{
+    HRESULT hr = S_OK;
+    LONGLONG llValue = 0;
+    LPWSTR sczValue = NULL;
+    DWORD64 qwValue = 0;
+    BOOL fEncrypt = pVariant->fEncryptValue;
+
+    switch (pValue->Type)
+    {
+    case BURN_VARIANT_TYPE_NONE:
+        BVariantUninitialize(pVariant);
+        break;
+    case BURN_VARIANT_TYPE_NUMERIC:
+        hr = BVariantGetNumeric(pValue, &llValue);
+        if (SUCCEEDED(hr))
+        {
+            hr = BVariantSetNumeric(pVariant, llValue);
+        }
+        SecureZeroMemory(&llValue, sizeof(llValue));
+        break;
+    case BURN_VARIANT_TYPE_STRING:
+        hr = BVariantGetString(pValue, &sczValue);
+        if (SUCCEEDED(hr))
+        {
+            hr = BVariantSetString(pVariant, sczValue, 0);
+        }
+        StrSecureZeroFreeString(sczValue);
+        break;
+    case BURN_VARIANT_TYPE_VERSION:
+        hr = BVariantGetVersion(pValue, &qwValue);
+        if (SUCCEEDED(hr))
+        {
+            hr = BVariantSetVersion(pVariant, qwValue);
+        }
+        SecureZeroMemory(&qwValue, sizeof(qwValue));
+        break;
+    default:
+        hr = E_INVALIDARG;
+    }
+    ExitOnFailure(hr, "Failed to copy variant.");
+
+    hr = BVariantSetEncryption(pVariant, fEncrypt);
+
+LExit:
+    return hr;
+}
+
+extern "C" HRESULT BVariantCopy(
+    __in BURN_VARIANT* pSource,
+    __out BURN_VARIANT* pTarget
+    )
+{
+    HRESULT hr = S_OK;
+    LONGLONG llValue = 0;
+    LPWSTR sczValue = NULL;
+    DWORD64 qwValue = 0;
+
+    BVariantUninitialize(pTarget);
+
+    switch (pSource->Type)
+    {
+    case BURN_VARIANT_TYPE_NONE:
+        break;
+    case BURN_VARIANT_TYPE_NUMERIC:
+        hr = BVariantGetNumeric(pSource, &llValue);
+        if (SUCCEEDED(hr))
+        {
+            hr = BVariantSetNumeric(pTarget, llValue);
+        }
+        SecureZeroMemory(&llValue, sizeof(llValue));
+        break;
+    case BURN_VARIANT_TYPE_STRING:
+        hr = BVariantGetString(pSource, &sczValue);
+        if (SUCCEEDED(hr))
+        {
+            hr = BVariantSetString(pTarget, sczValue, 0);
+        }
+        StrSecureZeroFreeString(sczValue);
+        break;
+    case BURN_VARIANT_TYPE_VERSION:
+        hr = BVariantGetVersion(pSource, &qwValue);
+        if (SUCCEEDED(hr))
+        {
+            hr = BVariantSetVersion(pTarget, qwValue);
+        }
+        SecureZeroMemory(&qwValue, sizeof(qwValue));
+        break;
+    default:
+        hr = E_INVALIDARG;
+    }
+    ExitOnFailure(hr, "Failed to copy variant.");
+
+    hr = BVariantSetEncryption(pTarget, pSource->fEncryptValue);
+
+LExit:
+    return hr;
+}
+
+extern "C" HRESULT BVariantChangeType(
+    __in BURN_VARIANT* pVariant,
+    __in BURN_VARIANT_TYPE type
+    )
+{
+    HRESULT hr = S_OK;
+    BURN_VARIANT variant = { };
+    BOOL fEncryptValue = pVariant->fEncryptValue;
+
+    if (pVariant->Type == type)
+    {
+        ExitFunction(); // variant already is of the requested type
+    }
+
+    switch (type)
+    {
+    case BURN_VARIANT_TYPE_NONE:
+        hr = S_OK;
+        break;
+    case BURN_VARIANT_TYPE_NUMERIC:
+        hr = BVariantGetNumeric(pVariant, &variant.llValue);
+        break;
+    case BURN_VARIANT_TYPE_STRING:
+        hr = BVariantGetString(pVariant, &variant.sczValue);
+        break;
+    case BURN_VARIANT_TYPE_VERSION:
+        hr = BVariantGetVersion(pVariant, &variant.qwValue);
+        break;
+    default:
+        ExitFunction1(hr = E_INVALIDARG);
+    }
+    ExitOnFailure(hr, "Failed to copy variant value.");
+    variant.Type = type;
+
+    BVariantUninitialize(pVariant);
+    memcpy_s(pVariant, sizeof(BURN_VARIANT), &variant, sizeof(BURN_VARIANT));
+    SecureZeroMemory(&variant, sizeof(BURN_VARIANT));
+    BVariantSetEncryption(pVariant, fEncryptValue);
+
+LExit:
+    return hr;
+}
+
+extern "C" HRESULT BVariantSetEncryption(
+    __in BURN_VARIANT* pVariant,
+    __in BOOL fEncrypt
+    )
+{
+    HRESULT hr = S_OK;
+
+    if (pVariant->fEncryptValue == fEncrypt)
+    {
+        // The requested encryption state is already applied.
+        ExitFunction();
+    }
+    
+    switch (pVariant->Type)
+    {
+    case BURN_VARIANT_TYPE_NONE:
+        hr = S_OK;
+        break;
+    case BURN_VARIANT_TYPE_NUMERIC:
+        hr = BVariantEncryptNumeric(pVariant, fEncrypt);
+        break;
+    case BURN_VARIANT_TYPE_STRING:
+        hr = BVariantEncryptString(pVariant, fEncrypt);
+        break;
+    case BURN_VARIANT_TYPE_VERSION:
+        hr = BVariantEncryptVersion(pVariant, fEncrypt);
+        break;
+    default:
+        hr = E_INVALIDARG;
+    }
+    ExitOnFailure(hr, "Failed to set the variant's encryption state");
+    pVariant->fEncryptValue = fEncrypt;
+
+LExit:
+    return hr;
+}
+
+static HRESULT BVariantEncryptNumeric(
+    __in BURN_VARIANT* pVariant,
+    __in BOOL fEncrypt
+    )
+{
+    HRESULT hr = S_OK;
+
+    if (fEncrypt)
+    {
+        hr = CrypEncryptMemory(&pVariant->llValue, sizeof(pVariant->encryptionPadding), VARIANT_ENCRYPTION_SCOPE);
+    }
+    else
+    {
+        hr = CrypDecryptMemory(&pVariant->llValue, sizeof(pVariant->encryptionPadding), VARIANT_ENCRYPTION_SCOPE);
+    }
+
+//LExit:
+    return hr;
+}
+
+static HRESULT BVariantEncryptString(
+    __in BURN_VARIANT* pVariant,
+    __in BOOL fEncrypt
+    )
+{
+    HRESULT hr = S_OK;
+    SIZE_T cbData = 0;
+
+    if (NULL == pVariant->sczValue)
+    {
+        ExitFunction();
+    }
+
+    cbData = MemSize(pVariant->sczValue);
+    if (-1 == cbData)
+    {
+        hr = E_INVALIDARG;
+        ExitOnFailure(hr, "Failed to get the size of the string");
+    }
+    
+    DWORD remainder = fEncrypt ? cbData % CRYP_ENCRYPT_MEMORY_SIZE : 0;
+    DWORD extraNeeded = 0 < remainder ? CRYP_ENCRYPT_MEMORY_SIZE - remainder : 0;
+    if ((MAXDWORD - extraNeeded) < cbData)
+    {
+        hr = E_INVALIDDATA;
+        ExitOnFailure(hr, "The string is too big: size %u", cbData);
+    }
+    else if (0 < extraNeeded)
+    {
+        cbData += extraNeeded;
+        LPVOID pvNew = NULL;
+        hr = MemReAllocSecure(static_cast<LPVOID>(pVariant->sczValue), cbData, TRUE, &pvNew);
+        ExitOnFailure(hr, "Failed to resize the string so it could be encrypted");
+        pVariant->sczValue = static_cast<LPWSTR>(pvNew);
+    }
+    
+    if (fEncrypt)
+    {
+        hr = CrypEncryptMemory(pVariant->sczValue, static_cast<DWORD>(cbData), VARIANT_ENCRYPTION_SCOPE);
+    }
+    else
+    {
+        hr = CrypDecryptMemory(pVariant->sczValue, static_cast<DWORD>(cbData), VARIANT_ENCRYPTION_SCOPE);
+    }
+
+LExit:
+    return hr;
+}
+
+static HRESULT BVariantEncryptVersion(
+    __in BURN_VARIANT* pVariant,
+    __in BOOL fEncrypt
+    )
+{
+    HRESULT hr = S_OK;
+
+    if (fEncrypt)
+    {
+        hr = CrypEncryptMemory(&pVariant->qwValue, sizeof(pVariant->encryptionPadding), VARIANT_ENCRYPTION_SCOPE);
+    }
+    else
+    {
+        hr = CrypDecryptMemory(&pVariant->qwValue, sizeof(pVariant->encryptionPadding), VARIANT_ENCRYPTION_SCOPE);
+    }
+
+//LExit:
+    return hr;
+}
+
+// The contents of pllValue may be sensitive, should keep encrypted and SecureZeroMemory.
+static HRESULT BVariantRetrieveDecryptedNumeric(
+    __in BURN_VARIANT* pVariant,
+    __out LONGLONG* pllValue
+    )
+{
+    HRESULT hr = S_OK;
+
+    Assert(NULL != pllValue);
+    if (pVariant->fEncryptValue)
+    {
+        hr = BVariantEncryptNumeric(pVariant, FALSE);
+        ExitOnFailure(hr, "Failed to decrypt numeric");
+    }
+
+    *pllValue = pVariant->llValue;
+
+    if (pVariant->fEncryptValue)
+    {
+        hr = BVariantEncryptNumeric(pVariant, TRUE);
+    }
+
+LExit:
+    return hr;
+}
+
+// The contents of psczValue may be sensitive, should keep encrypted and SecureZeroFree.
+static HRESULT BVariantRetrieveDecryptedString(
+    __in BURN_VARIANT* pVariant,
+    __out LPWSTR* psczValue
+    )
+{
+    HRESULT hr = S_OK;
+
+    if (NULL == pVariant->sczValue)
+    {
+        *psczValue = NULL;
+        ExitFunction();
+    }
+
+    if (pVariant->fEncryptValue)
+    {
+        hr = BVariantEncryptString(pVariant, FALSE);
+        ExitOnFailure(hr, "Failed to decrypt string");
+    }
+
+    hr = StrAllocStringSecure(psczValue, pVariant->sczValue, 0);
+    ExitOnFailure(hr, "Failed to copy value.");
+
+    if (pVariant->fEncryptValue)
+    {
+        hr = BVariantEncryptString(pVariant, TRUE);
+    }
+
+LExit:
+    return hr;
+}
+
+// The contents of pqwValue may be sensitive, should keep encrypted and SecureZeroMemory.
+static HRESULT BVariantRetrieveDecryptedVersion(
+    __in BURN_VARIANT* pVariant,
+    __out DWORD64* pqwValue
+    )
+{
+    HRESULT hr = S_OK;
+
+    Assert(NULL != pqwValue);
+    if (pVariant->fEncryptValue)
+    {
+        hr = BVariantEncryptVersion(pVariant, FALSE);
+        ExitOnFailure(hr, "Failed to decrypt version");
+    }
+
+    *pqwValue = pVariant->qwValue;
+
+    if (pVariant->fEncryptValue)
+    {
+        hr = BVariantEncryptVersion(pVariant, TRUE);
+    }
+
+LExit:
+    return hr;
+}
diff --git a/src/engine/variant.h b/src/engine/variant.h
new file mode 100644
index 00000000..9259f05a
--- /dev/null
+++ b/src/engine/variant.h
@@ -0,0 +1,102 @@
+#pragma once
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+
+// constants
+
+enum BURN_VARIANT_TYPE
+{
+    BURN_VARIANT_TYPE_NONE,
+    BURN_VARIANT_TYPE_NUMERIC,
+    BURN_VARIANT_TYPE_STRING,
+    BURN_VARIANT_TYPE_VERSION,
+};
+
+
+// struct
+
+typedef struct _BURN_VARIANT
+{
+    union
+    {
+        LONGLONG llValue;
+        DWORD64 qwValue;
+        LPWSTR sczValue;
+        BYTE encryptionPadding[CRYP_ENCRYPT_MEMORY_SIZE];
+    };
+    BURN_VARIANT_TYPE Type;
+    BOOL fEncryptValue;
+} BURN_VARIANT;
+
+
+// function declarations
+
+void BVariantUninitialize(
+    __in BURN_VARIANT* pVariant
+    );
+HRESULT BVariantGetNumeric(
+    __in BURN_VARIANT* pVariant,
+    __out LONGLONG* pllValue
+    );
+HRESULT BVariantGetString(
+    __in BURN_VARIANT* pVariant,
+    __out_z LPWSTR* psczValue
+    );
+HRESULT BVariantGetVersion(
+    __in BURN_VARIANT* pVariant,
+    __out DWORD64* pqwValue
+    );
+HRESULT BVariantSetNumeric(
+    __in BURN_VARIANT* pVariant,
+    __in LONGLONG llValue
+    );
+HRESULT BVariantSetString(
+    __in BURN_VARIANT* pVariant,
+    __in_z_opt LPCWSTR wzValue,
+    __in DWORD_PTR cchValue
+    );
+HRESULT BVariantSetVersion(
+    __in BURN_VARIANT* pVariant,
+    __in DWORD64 qwValue
+    );
+/********************************************************************
+BVariantSetValue - Convenience function that calls BVariantUninitialize,
+                   BVariantSetNumeric, BVariantSetString, or 
+                   BVariantSetVersion based on the type of pValue.
+                   The encryption state of pVariant is preserved.
+********************************************************************/
+HRESULT BVariantSetValue(
+    __in BURN_VARIANT* pVariant,
+    __in BURN_VARIANT* pValue
+    );
+/********************************************************************
+BVariantCopy - creates a copy of pSource.
+               The encryption state of pTarget is set to
+               the encryption state of pSource.
+********************************************************************/
+HRESULT BVariantCopy(
+    __in BURN_VARIANT* pSource,
+    __out BURN_VARIANT* pTarget
+    );
+HRESULT BVariantChangeType(
+    __in BURN_VARIANT* pVariant,
+    __in BURN_VARIANT_TYPE type
+    );
+/********************************************************************
+BVariantSetEncryption - sets the encryption state of pVariant.
+                        If the encryption state matches the requested
+                        state, this function does nothing.
+********************************************************************/
+HRESULT BVariantSetEncryption(
+    __in BURN_VARIANT* pVariant,
+    __in BOOL fEncrypt
+    );
+
+#if defined(__cplusplus)
+}
+#endif
diff --git a/src/stub/StubSection.cpp b/src/stub/StubSection.cpp
new file mode 100644
index 00000000..962bb3cf
--- /dev/null
+++ b/src/stub/StubSection.cpp
@@ -0,0 +1,23 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+#include "precomp.h"
+
+#pragma section(".wixburn",read)
+
+// If these defaults ever change, be sure to update constants in burn\engine\section.cpp as well.
+#pragma data_seg(push, ".wixburn")
+static DWORD dwMagic = 0x00f14300;
+static DWORD dwVersion = 0x00000002;
+
+static GUID guidBundleId = { };
+
+static DWORD dwStubSize = 0;
+static DWORD dwOriginalChecksum = 0;
+static DWORD dwOriginalSignatureOffset = 0;
+static DWORD dwOriginalSignatureSize = 0;
+
+static DWORD dwContainerFormat = 1;
+static DWORD dwContainerCount = 0;
+static DWORD qwBootstrapperApplicationContainerSize = 0;
+static DWORD qwAttachedContainerSize = 0;
+#pragma data_seg(pop)
diff --git a/src/stub/precomp.h b/src/stub/precomp.h
new file mode 100644
index 00000000..387d4f0f
--- /dev/null
+++ b/src/stub/precomp.h
@@ -0,0 +1,13 @@
+#pragma once
+// 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.
+
+
+#include <windows.h>
+
+#include <dutil.h>
+#include <apputil.h>
+#include <strutil.h>
+#include <fileutil.h>
+#include <pathutil.h>
+
+#include "engine.h"
diff --git a/src/stub/stub.cpp b/src/stub/stub.cpp
new file mode 100644
index 00000000..2f09eede
--- /dev/null
+++ b/src/stub/stub.cpp
@@ -0,0 +1,64 @@
+// 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.
+
+#include "precomp.h"
+
+
+int WINAPI wWinMain(
+    __in HINSTANCE hInstance,
+    __in_opt HINSTANCE /* hPrevInstance */,
+    __in_z_opt LPWSTR lpCmdLine,
+    __in int nCmdShow
+    )
+{
+    HRESULT hr = S_OK;
+    DWORD dwExitCode = 0;
+    LPWSTR sczPath = NULL;
+    HANDLE hEngineFile = INVALID_HANDLE_VALUE;
+
+    LPCWSTR rgsczSafelyLoadSystemDlls[] =
+    {
+        L"cabinet.dll", // required by Burn.
+        L"msi.dll", // required by Burn.
+        L"version.dll", // required by Burn.
+        L"wininet.dll", // required by Burn.
+
+        L"comres.dll", // required by CLSIDFromProgID() when loading clbcatq.dll.
+        L"clbcatq.dll", // required by CLSIDFromProgID() when loading msxml?.dll.
+
+        L"msasn1.dll", // required by DecryptFile() when loading crypt32.dll.
+        L"crypt32.dll", // required by DecryptFile() when loading feclient.dll.
+        L"feclient.dll", // unsafely loaded by DecryptFile().
+    };
+
+    // Best effort attempt to get our file handle as soon as possible.
+    hr = PathForCurrentProcess(&sczPath, NULL);
+    if (SUCCEEDED(hr))
+    {
+        hEngineFile = ::CreateFileW(sczPath, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_DELETE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+    }
+
+    // If the engine is in the clean room, we'll do the unsafe initialization
+    // because some systems in Windows (namely GDI+) will fail when run in
+    // a process that protects against DLL hijacking. Since we know the clean
+    // room is in a clean folder and not subject to DLL hijacking we won't
+    // make ourselves perfectly secure so that we can load BAs that still
+    // depend on those parts of Windows that are insecure to DLL hijacking.
+    if (EngineInCleanRoom(lpCmdLine))
+    {
+        AppInitializeUnsafe();
+    }
+    else
+    {
+        AppInitialize(rgsczSafelyLoadSystemDlls, countof(rgsczSafelyLoadSystemDlls));
+    }
+
+    // call run
+    hr = EngineRun(hInstance, hEngineFile, lpCmdLine, nCmdShow, &dwExitCode);
+    ExitOnFailure(hr, "Failed to run application.");
+
+LExit:
+    ReleaseFileHandle(hEngineFile);
+    ReleaseStr(sczPath);
+
+    return FAILED(hr) ? (int)hr : (int)dwExitCode;
+}
diff --git a/src/stub/stub.ico b/src/stub/stub.ico
new file mode 100644
index 00000000..c2e2717c
--- /dev/null
+++ b/src/stub/stub.ico
diff --git a/src/stub/stub.manifest b/src/stub/stub.manifest
new file mode 100644
index 00000000..d5767cdb
--- /dev/null
+++ b/src/stub/stub.manifest
@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<!-- 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. -->
+
+
+<assembly xmlns="urn:schemas-microsoft-com:asm.v1" xmlns:asmv3="urn:schemas-microsoft-com:asm.v3" manifestVersion="1.0">
+ <assemblyIdentity name="setup.exe" version="1.0.0.0" processorArchitecture="x86" type="win32"/>
+ <description>WiX Toolset Bootstrapper</description>
+ <asmv3:application><asmv3:windowsSettings><ws:dpiAware xmlns:ws="http://schemas.microsoft.com/SMI/2005/WindowsSettings">true</ws:dpiAware></asmv3:windowsSettings></asmv3:application>
+ <dependency><dependentAssembly><assemblyIdentity type="win32" name="Microsoft.Windows.Common-Controls" version="6.0.0.0" processorArchitecture="X86" publicKeyToken="6595b64144ccf1df" language="*" /></dependentAssembly></dependency>
+ <compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1"><application>
+  <supportedOS Id="{e2011457-1546-43c5-a5fe-008deee3d3f0}"/>
+  <supportedOS Id="{35138b9a-5d96-4fbd-8e2d-a2440225f93a}"/>
+  <supportedOS Id="{4a2f28e3-53b9-4441-ba9c-d69d4a4a6e38}"/>
+  <supportedOS Id="{1f676c76-80e1-4239-95bb-83d0f6d0da78}"/>
+  <supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}"/>
+ </application></compatibility>
+ <trustInfo xmlns="urn:schemas-microsoft-com:asm.v3"><security><requestedPrivileges><requestedExecutionLevel level="asInvoker" uiAccess="false"/></requestedPrivileges></security></trustInfo>
+</assembly>
diff --git a/src/stub/stub.rc b/src/stub/stub.rc
new file mode 100644
index 00000000..5601703d
--- /dev/null
+++ b/src/stub/stub.rc
@@ -0,0 +1,14 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+#define VER_APP
+#define VER_ORIGINAL_FILENAME "setup.exe"
+#define VER_INTERNAL_NAME "setup"
+#define VER_FILE_DESCRIPTION "WiX Toolset Bootstrapper"
+#include "wix.rc"
+
+1 ICON "stub.ico"
+
+//#define MANIFEST_RESOURCE_ID 1
+#ifndef ARM // the ARM manifest is automatically injected but other platforms need it done manually.
+//MANIFEST_RESOURCE_ID RT_MANIFEST "stub.manifest"
+#endif