update

Moved `PendingGhostSpawnEntry` into the GhostSpawnManager.cs file.
Made `PendingGhostSpawnEntry` implement `IDisposable` for simplification and best practices purposes.

Author: NoelStephensUnity

com.unity.netcode.gameobjects/Runtime/SceneManagement/SceneEventData.cs

@@ -1309,7 +1309,6 @@ private void DeserializeObjectsMovedIntoNewScene(FastBufferReader reader)
             }
         }
 
-
         /// <summary>
         /// While a client is synchronizing ObjectSceneChanged messages could be received.
         /// This defers any ObjectSceneChanged message processing to occur after the client
@@ -1414,20 +1413,4 @@ internal SceneEventData(NetworkManager networkManager)
             SceneEventId = XXHash.Hash32(Guid.NewGuid().ToString());
         }
     }
-
-#if UNIFIED_NETCODE
-    /// <summary>
-    /// Used to store pending ghost spawns that are waiting for their associated (N4E) ghost to be spawned before they can be fully deserialized and
-    /// spawned during the scene synchronization process. This is necessary because in unified mode we allow for NetworkObjects with ghost components
-    /// to be synchronized during the scene synchronization process but we can't guarantee the order of messages that the client receives so we
-    /// need to defer the deserialization of any NetworkObject that has a ghost component until we have received the message that the ghost has
-    /// been spawned and we have an instance to deserialize this information into.
-    /// </summary>
-    internal struct PendingGhostSpawnEntry
-    {
-        public float RegistrationTime;
-        public FastBufferReader Buffer;
-        public NetworkObject.SerializedObject SerializedObject;
-    }
-#endif
 }

com.unity.netcode.gameobjects/Runtime/Spawning/GhostSpawnManager.cs

@@ -1,12 +1,18 @@
 #if UNIFIED_NETCODE
+using System;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using Unity.Collections;
 using Unity.Netcode.Logging;
 using UnityEngine;
+using Object = UnityEngine.Object;
 
 namespace Unity.Netcode
 {
+    /// <summary>
+    /// Handles the management of ghost spawns during the synchronization process. This includes tracking pending NetworkObject spawns
+    /// that are waiting for their associated ghost to be spawned before they can be fully deserialized.
+    /// </summary>
     internal class GhostSpawnManager
     {
         private readonly NetworkManager m_NetworkManager;
@@ -139,16 +145,19 @@ internal NetworkObject ProcessGhostPendingSynchronization(ulong networkObjectId,
                 m_NetworkManager.SceneManager.SetTheSceneBeingSynchronized(serializedObject.NetworkSceneHandle);
             }
             var networkObject = NetworkObject.Deserialize(serializedObject, reader, m_NetworkManager);
+
             // TODO-UNIFIED: How do we handle the "all in-scene placed objects are spawned notification"?
             //if (serializedObject.IsSceneObject)
             //{
             //    networkObject.InternalInSceneNetworkObjectsSpawned();
             //}
+
+            // If removing, determine if we have any pending ghosts remaining and dispose of this ghost's pending synchronization buffer.
+            // If not removing, then we will keep the buffer around until we do remove it (either via spawn or timeout).
             if (removeUponSpawn)
             {
-                m_GhostsPendingSynchronization.Remove(networkObjectId);
                 m_GhostsArePendingSynchronization = m_GhostsPendingSynchronization.Count > 0;
-                ghostPendingSync.Buffer.Dispose();
+                ghostPendingSync.Dispose();
             }
             return networkObject;
         }
@@ -255,5 +264,24 @@ internal void Shutdown()
             m_GhostsPendingSynchronization.Clear();
         }
     }
+
+    /// <summary>
+    /// Used to store pending ghost spawns that are waiting for their associated (N4E) ghost to be spawned before they can be fully deserialized and
+    /// spawned during the scene synchronization process. This is necessary because in unified mode we allow for NetworkObjects with ghost components
+    /// to be synchronized during the scene synchronization process but we can't guarantee the order of messages that the client receives so we
+    /// need to defer the deserialization of any NetworkObject that has a ghost component until we have received the message that the ghost has
+    /// been spawned and we have an instance to deserialize this information into.
+    /// </summary>
+    internal struct PendingGhostSpawnEntry : IDisposable
+    {
+        public float RegistrationTime;
+        public FastBufferReader Buffer;
+        public NetworkObject.SerializedObject SerializedObject;
+
+        public void Dispose()
+        {
+            Buffer.Dispose();
+        }
+    }
 }
 #endif