Fix TerminalLogger IndexOutOfRangeException when replaying binlog with fewer nodes

src/Build.UnitTests/TerminalLogger_Tests.cs

@@ -1018,6 +1018,72 @@ public async Task ProjectFinishedReportsTargetFrameworkAndRuntimeIdentifier()
             await Verify(_outputWriter.ToString(), _settings).UniqueForOSPlatform();
         }
 
+        [Fact]
+        public void ReplayBinaryLogWithFewerNodesThanOriginalBuild()
+        {
+            // This test validates that replaying a binary log with terminal logger
+            // using fewer nodes than the original build does not cause an IndexOutOfRangeException.
+            // See issue: https://github.com/dotnet/msbuild/issues/10596
+
+            using (TestEnvironment env = TestEnvironment.Create())
+            {
+                // Create multiple projects that will build in parallel
+                TransientTestFolder logFolder = env.CreateFolder(createFolder: true);
+
+                // Create three simple projects
+                TransientTestFile project1 = env.CreateFile(logFolder, "project1.proj", @"
+<Project>
+    <Target Name='Build'>
+        <Message Text='Building project1' Importance='High' />
+    </Target>
+</Project>");
+
+                TransientTestFile project2 = env.CreateFile(logFolder, "project2.proj", @"
+<Project>
+    <Target Name='Build'>
+        <Message Text='Building project2' Importance='High' />
+    </Target>
+</Project>");
+
+                TransientTestFile project3 = env.CreateFile(logFolder, "project3.proj", @"
+<Project>
+    <Target Name='Build'>
+        <Message Text='Building project3' Importance='High' />
+    </Target>
+</Project>");
+
+                // Create a solution file that builds all projects in parallel
+                string solutionContents = $@"
+<Project>
+    <Target Name='Build'>
+        <MSBuild Projects='{project1.Path};{project2.Path};{project3.Path}' BuildInParallel='true' />
+    </Target>
+</Project>";
+                TransientTestFile solutionFile = env.CreateFile(logFolder, "solution.proj", solutionContents);
+
+                string binlogPath = env.ExpectFile(".binlog").Path;
+
+                // Build with multiple nodes to create a binlog with higher node IDs
+                RunnerUtilities.ExecMSBuild($"{solutionFile.Path} /m:4 /bl:{binlogPath}", out bool success, outputHelper: _outputHelper);
+                success.ShouldBeTrue();
+
+                // Replay the binlog with TerminalLogger using only 1 node
+                // This should NOT throw an IndexOutOfRangeException
+                var replayEventSource = new BinaryLogReplayEventSource();
+                using var outputWriter = new StringWriter();
+                using var mockTerminal = new Terminal(outputWriter);
+                var terminalLogger = new TerminalLogger(mockTerminal);
+
+                // Initialize with only 1 node (fewer than the original build)
+                terminalLogger.Initialize(replayEventSource, nodeCount: 1);
+
+                // This should complete without throwing an exception
+                Should.NotThrow(() => replayEventSource.Replay(binlogPath));
+
+                terminalLogger.Shutdown();
+            }
+        }
+
         [Theory]
         [InlineData(true)]
         [InlineData(false)]

src/Build/Logging/TerminalLogger/TerminalLogger.cs

@@ -151,6 +151,11 @@ public EvalContext(BuildEventContext context)
     /// </summary>
     private ProjectContext? _restoreContext;
 
+    /// <summary>
+    /// True if we're replaying a binary log. In this mode, we may encounter NodeIds higher than the initial node count.
+    /// </summary>
+    private bool _isReplayMode = false;
+
     /// <summary>
     /// The thread that performs periodic refresh of the console output.
     /// </summary>
@@ -432,6 +437,9 @@ public void Initialize(IEventSource eventSource)
     {
         ParseParameters();
 
+        // Detect if we're in replay mode
+        _isReplayMode = eventSource is IBinaryLogReplaySource;
+
         eventSource.BuildStarted += BuildStarted;
         eventSource.BuildFinished += BuildFinished;
         eventSource.ProjectStarted += ProjectStarted;
@@ -732,6 +740,7 @@ private void ProjectStarted(object sender, ProjectStartedEventArgs e)
             {
                 _restoreContext = c;
                 int nodeIndex = NodeIndexForContext(e.BuildEventContext);
+                EnsureNodeCapacity(nodeIndex);
                 _nodes[nodeIndex] = new TerminalNodeStatus(e.ProjectFile!, targetFramework, runtimeIdentifier, "Restore", _projects[c].Stopwatch);
             }
         }
@@ -1047,9 +1056,31 @@ private void TargetStarted(object sender, TargetStartedEventArgs e)
     private void UpdateNodeStatus(BuildEventContext buildEventContext, TerminalNodeStatus? nodeStatus)
     {
         int nodeIndex = NodeIndexForContext(buildEventContext);
+        EnsureNodeCapacity(nodeIndex);
         _nodes[nodeIndex] = nodeStatus;
     }
 
+    /// <summary>
+    /// Ensures that the <see cref="_nodes"/> array has enough capacity to accommodate the given index.
+    /// This is necessary for binary log replay scenarios where the replay may use fewer nodes than the original build.
+    /// </summary>
+    private void EnsureNodeCapacity(int nodeIndex)
+    {
+        // Only resize in replay mode - during normal builds, the node count is fixed
+        if (_isReplayMode && nodeIndex >= _nodes.Length)
+        {
+            // Resize to accommodate the new index plus some extra capacity
+            lock (_lock)
+            {
+                if (nodeIndex >= _nodes.Length)
+                {
+                    int newSize = Math.Max(nodeIndex + 1, _nodes.Length * 2);
+                    Array.Resize(ref _nodes, newSize);
+                }
+            }
+        }
+    }
+
     /// <summary>
     /// The <see cref="IEventSource.TargetFinished"/> callback. Unused.
     /// </summary>
@@ -1185,7 +1216,9 @@ private void MessageRaised(object sender, BuildMessageEventArgs e)
 
             if (hasProject && project!.IsTestProject)
             {
-                TerminalNodeStatus? node = _nodes[NodeIndexForContext(buildEventContext)];
+                int nodeIndex = NodeIndexForContext(buildEventContext);
+                EnsureNodeCapacity(nodeIndex);
+                TerminalNodeStatus? node = _nodes[nodeIndex];
 
                 // Consumes test update messages produced by VSTest and MSTest runner.
                 if (e is IExtendedBuildEventArgs extendedMessage)