private RunOutput Run(RunConfig config, CancellationToken abortToken)
{
    var common = new PowerShellCommonHelpers();
    // ReSharper disable ConvertToUsingDeclaration
    using (var eFs = new FileStream(config.ErrorFilePath, FileMode.Create, FileAccess.Write, FileShare.None))
    using (var errorWriter = new StreamWriter(eFs, new UTF8Encoding(false)))
    using (var oFs = new FileStream(config.OutputFilePath, FileMode.Create, FileAccess.Write, FileShare.None))
    using (var outputWriter = new StreamWriter(oFs, new UTF8Encoding(false)) { AutoFlush = false })
    {
        var runOutput = new RunOutput();

        var strPrevousExecutionPolicy = string.Empty;
        var ysnOk = true;

        if (config.OverrideExecutionPolicy)
        {
            //Check if PowerShell GPO is active; do NOT set execution policy if GPO is active because it will fail!
            if (PowerShellCommon.fysnPowerShellGpoActive())
                config.OverrideExecutionPolicy = false;
            //To prevent reset to original execution policy later on
            else
                ysnOk = PowerShellCommon.fysnSetExecutionPolicy("Unrestricted", ref strPrevousExecutionPolicy);
        }

        if (ysnOk)
        {
            // ReSharper disable once UnusedVariable USED FOR DEBUGGING
            const string resourceText = "";
            var scriptToRun = string.IsNullOrEmpty(resourceText)
                ? config.Source
                : File.ReadAllText(resourceText);

            var myRunSpaceConfiguration = TryLoadConsoleFile(config, errorWriter, outputWriter);

            var myRespsHost = new RESStreamingPSHost();
            myRespsHost.ProgressMessage += MyRespsHostOnProgressMessage;
            // ReSharper disable once AccessToDisposedClosure lambda is in scope.
            myRespsHost.OnOutput += value => outputWriter.Write(value);
            // ReSharper disable once AccessToDisposedClosure lambda is in scope.
            myRespsHost.OnError += value => errorWriter.Write(value);


            if (config.OutputWidth == 0) config.OutputWidth = 16386;

            RESDiagnostics.TraceInfo("Changing output buffer width to {0}.", config.OutputWidth);
            myRespsHost.BufferSize = new Size(config.OutputWidth, 1000);

            Runspace myRunSpace;
            if (myRunSpaceConfiguration != null)
            {
                myRunSpace = RunspaceFactory.CreateRunspace(myRespsHost, myRunSpaceConfiguration);
                RESDiagnostics.TraceInfo("Done loading with settings.");
            }
            else
            {
                myRunSpace = RunspaceFactory.CreateRunspace(myRespsHost);
                RESDiagnostics.TraceInfo("Done loading without settings.");
            }

            myRunSpace.Open();

            var myPipeLine = CreatePipeline(myRunSpace, scriptToRun, config.Mappings);

            RESDiagnostics.TraceInfo($"Running script.{scriptToRun}");
            try
            {
                var abortCheckerTokenSource = new CancellationTokenSource();
                Task.Factory.StartNew(
                    (abortChecker) =>
                    {
                        while (!abortToken.IsCancellationRequested && !abortCheckerTokenSource.Token.IsCancellationRequested)
                        {
                            Thread.Sleep(200);
                        }

                        if (abortToken.IsCancellationRequested)
                        {
                            myRunSpace.Close();
                            myPipeLine.Stop();
                        }
                    }, abortCheckerTokenSource.Token);

                var myResults =
                    StopwatchExtensions.TraceTimeOf("Running script.", () => myPipeLine.Invoke());

                abortCheckerTokenSource.Cancel();
                abortCheckerTokenSource.Dispose();

                if (abortToken.IsCancellationRequested)
                {
                    myRunSpace.Close();
                    return runOutput;
                }

                StopwatchExtensions.TraceTimeOf($"Output messages {myResults.Count}", outputStream =>
                {
                    foreach (var myPsObjectLoopVariable in myResults)
                    {
                        if (abortToken.IsCancellationRequested)
                        {
                            myRunSpace.Close();
                            return;
                        }

                        var myPsObject = myPsObjectLoopVariable;
                        if (myPsObject.BaseObject is ErrorRecord record)
                        {
                            outputStream.Write(record.ToString());
                            outputStream.WriteLine(record.InvocationInfo.PositionMessage);
                        }
                        else
                        {
                            outputStream.WriteLine(myPsObject.ToString());
                        }
                    }
                }, outputWriter);

                if (abortToken.IsCancellationRequested)
                {
                    return runOutput;
                }

                StopwatchExtensions.TraceTimeOf("Messages on the error pipeline", errorStream =>
                {
                    while (!myPipeLine.Error.EndOfPipeline)
                    {
                        if (abortToken.IsCancellationRequested)
                        {
                            myRunSpace.Close();
                            return;
                        }

                        var myPsObject = (PSObject)myPipeLine.Error.Read();
                        if (myPsObject.BaseObject is ErrorRecord record)
                        {
                            errorStream.Write(record.ToString());
                            errorStream.WriteLine(record.InvocationInfo.PositionMessage);
                        }
                        else
                        {
                            errorStream.WriteLine(myPsObject.ToString());
                        }
                    }
                }, errorWriter);

                if (abortToken.IsCancellationRequested)
                {
                    myRunSpace.Close();
                    return runOutput;
                }

                runOutput.ExitCode = myRespsHost.ExitCode;

                if (SidekickState.Instance.AgentIPC != null)
                {
                    StopwatchExtensions.TraceTimeOf("Extract Variables To Parameters", () =>
                    {
                        common.ExtractVariablesToParameters(myRunSpace, scriptToRun, OutputMaxSize, out _wasParameterTrimmed);
                    });

                    StopwatchExtensions.TraceTimeOf("Blob Override", () =>
                    {
                        var automationfabricbloboverride = common.GlobalParameterValue(
                            myRunSpace.SessionStateProxy.PSVariable,
                            "automationfabricbloboverride",
                            scriptToRun
                        );
                        if (automationfabricbloboverride == null) return;

                        _blobOverride = automationfabricbloboverride.ToString();
                        RESDiagnostics.TraceInfo($"blob overriden with length: {_blobOverride.Length}");
                    });
                }
            }
            catch (RuntimeException ex)
            {
                RESDiagnostics.TraceInfo($" RuntimeException: {ex.ToString()}");
                RESDiagnostics.TraceError($"A runtime exception occured");

                errorWriter.Write(ex.Message);

                if (ex.ErrorRecord.InvocationInfo != null)
                    errorWriter.WriteLine(ex.ErrorRecord.InvocationInfo.PositionMessage);
            }
            catch (Exception ex)
            {
                RESDiagnostics.TraceInfo($" Exception: {ex.ToString()}");
                RESDiagnostics.TraceError("A general exception occured.");

                errorWriter.Write(ex.Message);
            }


            RESDiagnostics.TraceInfo("Result code");
            var resultCodeValue = common.GlobalParameterValue(
                myRunSpace.SessionStateProxy.PSVariable,
                "resultcodeinternalapivalue",
                scriptToRun
            );


            if (resultCodeValue != null && int.TryParse(resultCodeValue.ToString(), out var resCode))
                runOutput.ResCode = resCode;

            try
            {
                RESDiagnostics.TraceInfo("Preparing to extract the extra log");

                var extraLog = common.GlobalParameterValue(
                    myRunSpace.SessionStateProxy.PSVariable,
                    "internalenginelogerrordetails",
                    scriptToRun
                )?.ToString();
                if (!string.IsNullOrEmpty(extraLog))
                {
                    RESDiagnostics.TraceError(extraLog);
                }
                else
                {
                    RESDiagnostics.TraceInfo("Extra log not found");
                }
            }
            catch (Exception e)
            {
                RESDiagnostics.TraceInfo($"Extra log exception {e.Message}, {e.StackTrace}");
            }




            myRunSpace.Close();

            if (!config.OverrideExecutionPolicy) return runOutput;

            RESDiagnostics.TraceInfo("Revert execution policy");
            string dummy = null;
            PowerShellCommon.fysnSetExecutionPolicy(strPrevousExecutionPolicy, ref dummy);
        }
        else
        {
            errorWriter.Write("Unable to set execution policy.");
        }

        return runOutput;
    }
}