com.beamable 5.0.1 → 5.1.0-PREVIEW.RC1

package/Editor/BeamCli/Commands/BeamUtilityTypeEntry.cs

@@ -0,0 +1,19 @@
+
+namespace Beamable.Editor.BeamCli.Commands
+{
+    using Beamable.Common;
+    using Beamable.Common.BeamCli;
+    
+    [System.SerializableAttribute()]
+    public partial class BeamUtilityTypeEntry
+    {
+        public string TypeName;
+        public string Namespace;
+        public string Kind;
+        public string Summary;
+        public string Platform;
+        public BeamUtilityMemberEntry[] Members;
+        public BeamUtilityMethodEntry[] Methods;
+        public string[] EnumValues;
+    }
+}

package/Editor/BeamCli/Commands/BeamUtilityTypeEntry.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 365d4f3df1649e3cba6e34ed284e6091
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Editor/BeamCli/UI/LogUtil/LogViewUtil.cs

@@ -263,6 +263,8 @@ namespace Beamable.Editor.BeamCli.UI.LogHelpers
 					return CliLogLevel.Info;
 				case "Fatal":
 				case "fatal":
+				case "critical":
+				case "Critical":
 					return CliLogLevel.Fatal;
 				case "Error":
 				case "error":

package/Editor/ContentService/CliContentService.cs

@@ -20,6 +20,21 @@ using Object = UnityEngine.Object;
 
 namespace Beamable.Editor.ContentService
 {
+	/// <summary>
+	/// Tracks the currently running content operation so the Content Manager can render progress inside the window.
+	/// </summary>
+	public class ContentOperationProgress
+	{
+		public bool IsActive;
+		public bool HasError;
+		public string Title = string.Empty;
+		public string Description = string.Empty;
+		public string CurrentContentName = string.Empty;
+		public int ProcessedItems;
+		public int TotalItems;
+		public float Progress;
+	}
+
 	public class CliContentService : IStorageHandler<CliContentService>, ILoadWithContext
 	{
 		private const string SYNC_OPERATION_TITLE = "Sync Contents";
@@ -45,6 +60,8 @@ namespace Beamable.Editor.ContentService
 		private List<string> _tagsCache = new();
 		private int syncedContents;
 		private int publishedContents;
+		private readonly Dictionary<string, string> _lastSavedPropertiesCache = new();
+		private bool _showUnityModalProgress;
 		
 		[NonSerialized]
 		public bool isReloading;
@@ -54,6 +71,14 @@ namespace Beamable.Editor.ContentService
 
 		private readonly Dictionary<string, ContentObject> _contentScriptableCache;
 		public BeamContentPsProgressMessage LatestProgressUpdate;
+		/// <summary>
+		/// Current publish or sync progress state consumed by the Content Manager IMGUI view.
+		/// </summary>
+		public ContentOperationProgress CurrentProgress { get; } = new();
+		/// <summary>
+		/// Monotonic value incremented when <see cref="CurrentProgress"/> changes so the Content Manager can repaint on demand.
+		/// </summary>
+		public int ProgressUpdateVersion { get; private set; }
 		private readonly ContentConfiguration _contentConfiguration;
 
 		private ValidationContext ValidationContext => _provider.GetService<ValidationContext>();
@@ -95,6 +120,16 @@ namespace Beamable.Editor.ContentService
 		public void SaveContent(ContentObject selectedContentObject)
 		{
 			string propertiesJson = ClientContentSerializer.SerializeProperties(selectedContentObject);
+
+			// This prevents save storms when the debounce fires for rapid-fire edits where
+			// the final serialised value is the same as what was already written.
+			if (_lastSavedPropertiesCache.TryGetValue(selectedContentObject.Id, out var lastJson)
+			    && lastJson == propertiesJson)
+			{
+				return;
+			}
+			_lastSavedPropertiesCache[selectedContentObject.Id] = propertiesJson;
+
 			bool hasValidationError = selectedContentObject.HasValidationErrors(GetValidationContext(), out List<string> _);
 			UpdateContentValidationStatus(selectedContentObject.Id, hasValidationError);
 			SaveContent(selectedContentObject.Id, propertiesJson, () => SetContentTags(selectedContentObject.Id, selectedContentObject.Tags));
@@ -194,11 +229,12 @@ namespace Beamable.Editor.ContentService
 		                                           bool syncConflicted,
 		                                           bool syncDeleted,
 		                                           string filter = null,
-		                                           ContentFilterType filterType = default)
+		                                           ContentFilterType filterType = default,
+		                                           bool showUnityModalProgress = false)
 		{
 
 			syncedContents = 0;
-			EditorUtility.DisplayProgressBar(SYNC_OPERATION_TITLE, "Synchronizing contents...", 0);
+			BeginActionProgress(SYNC_OPERATION_TITLE, "Synchronizing contents...", showUnityModalProgress);
 			try
 			{
 				if (_contentWatcher != null)
@@ -215,6 +251,7 @@ namespace Beamable.Editor.ContentService
 					syncDeleted = syncDeleted,
 					filter = filter,
 					filterType = filterType,
+					downloadMaxParallelCount = GetEditorSyncDownloadMaxParallelCountCliOption(),
 					
 				});
 
@@ -248,6 +285,7 @@ namespace Beamable.Editor.ContentService
 				syncDeleted = syncDeleted,
 				filter = filter,
 				filterType = filterType,
+				downloadMaxParallelCount = GetEditorSyncDownloadMaxParallelCountCliOption(),
 			});
 			
 			await contentSyncCommand.Run();
@@ -410,7 +448,7 @@ namespace Beamable.Editor.ContentService
 		
 		public async Promise PublishContentsWithProgress()
 		{
-			EditorUtility.DisplayProgressBar(PUBLISH_OPERATION_TITLE, "Publishing contents...", 0);
+			BeginActionProgress(PUBLISH_OPERATION_TITLE, "Publishing contents...", true);
 			publishedContents = 0;
 			
 			try
@@ -438,12 +476,60 @@ namespace Beamable.Editor.ContentService
 			}
 		}
 
+		/// <summary>
+		/// Finishes the active content operation, clears any modal progress UI, and reloads local content state.
+		/// </summary>
 		private void FinishActionProgress()
 		{
-			EditorUtility.ClearProgressBar();
+			if (_showUnityModalProgress)
+			{
+				EditorUtility.ClearProgressBar();
+			}
+
+			CurrentProgress.IsActive = false;
+			ProgressUpdateVersion++;
 			_ = Reload();
 		}
 
+		/// <summary>
+		/// Initializes progress state for a content operation. Sync can use in-window progress only, while publish can still opt into Unity's modal progress UI.
+		/// </summary>
+		private void BeginActionProgress(string title, string description, bool showUnityModalProgress)
+		{
+			_showUnityModalProgress = showUnityModalProgress;
+			CurrentProgress.IsActive = true;
+			CurrentProgress.Title = title;
+			CurrentProgress.Description = description;
+			CurrentProgress.CurrentContentName = string.Empty;
+			CurrentProgress.ProcessedItems = 0;
+			CurrentProgress.TotalItems = 0;
+			CurrentProgress.Progress = 0;
+			CurrentProgress.HasError = false;
+			ProgressUpdateVersion++;
+
+			if (_showUnityModalProgress)
+			{
+				EditorUtility.DisplayProgressBar(title, description, 0);
+			}
+		}
+
+		/// <summary>
+		/// Converts the optional editor sync concurrency setting to the CLI argument value.
+		/// </summary>
+		/// <remarks>
+		/// Returning the default int omits the CLI argument, allowing the CLI default to apply. A configured value of 0 maps to -1 so the generated command includes an explicit unbounded setting.
+		/// </remarks>
+		private int GetEditorSyncDownloadMaxParallelCountCliOption()
+		{
+			if (_contentConfiguration.EditorSyncDownloadMaxParallelCount?.HasValue != true)
+			{
+				return default;
+			}
+
+			var value = _contentConfiguration.EditorSyncDownloadMaxParallelCount.Value;
+			return value == 0 ? -1 : value;
+		}
+
 		public async Task PublishContents()
 		{
 			var contentPublishArgs = new ContentPublishArgs
@@ -619,6 +705,7 @@ namespace Beamable.Editor.ContentService
 			_statusContentCache.Clear();
 			_conflictedContentCache.Clear();
 			_contentIdTagsCache.Clear();
+			_lastSavedPropertiesCache.Clear();
 		}
 
 		public void ReceiveStorageHandle(StorageHandle<CliContentService> handle)
@@ -896,13 +983,23 @@ namespace Beamable.Editor.ContentService
 		                                string onSuccessBaseMessage,
 		                                string onErrorBaseMessage, ref int countItem)
 		{
-			string description = string.Empty;
-			float progress = (float)countItem / data.totalItems;
+			int totalItems = Math.Max(data.totalItems, 0);
+			string description = CurrentProgress.Description;
+			float progress = totalItems == 0 ? 0 : Mathf.Clamp01((float)countItem / totalItems);
+			int processedItemsForDisplay = countItem;
 
 			switch (data.EventType)
 			{
 				case 0: // Error on Content Progress Update
-					EditorUtility.ClearProgressBar();
+					CurrentProgress.HasError = true;
+					CurrentProgress.CurrentContentName = data.contentName;
+					CurrentProgress.TotalItems = totalItems;
+					CurrentProgress.Description = string.Format(onErrorBaseMessage, data.contentName, data.errorMessage);
+					ProgressUpdateVersion++;
+					if (_showUnityModalProgress)
+					{
+						EditorUtility.ClearProgressBar();
+					}
 					EditorUtility.DisplayDialog(
 						operationTitle,
 						string.Format(onErrorBaseMessage, data.contentName, data.errorMessage),
@@ -911,14 +1008,33 @@ namespace Beamable.Editor.ContentService
 					return;
 				case 1: // Sync Complete
 				case 2: // Publish Complete
-					description = string.Format(onSuccessBaseMessage, data.contentName, countItem, data.totalItems);
+					CurrentProgress.CurrentContentName = data.contentName;
+					int visibleCount = totalItems == 0 ? 0 : Mathf.Min(totalItems, countItem + 1);
+					processedItemsForDisplay = visibleCount;
+					description = string.Format(onSuccessBaseMessage, data.contentName, visibleCount, totalItems);
+					progress = totalItems == 0 ? 1 : Mathf.Clamp01((float)visibleCount / totalItems);
 					break;
 				case 3: // Update Processed item count
 					countItem = data.processedItems;
+					processedItemsForDisplay = totalItems == 0 ? countItem : Mathf.Min(countItem, totalItems);
+					progress = totalItems == 0 ? 1 : Mathf.Clamp01((float)processedItemsForDisplay / totalItems);
+					description = totalItems == 0
+						? $"{operationTitle} complete."
+						: $"{processedItemsForDisplay}/{totalItems} items processed.";
 					break;
 			}
 
-			EditorUtility.DisplayProgressBar(operationTitle, description, progress);
+			CurrentProgress.Title = operationTitle;
+			CurrentProgress.Description = description;
+			CurrentProgress.ProcessedItems = processedItemsForDisplay;
+			CurrentProgress.TotalItems = totalItems;
+			CurrentProgress.Progress = progress;
+			ProgressUpdateVersion++;
+
+			if (_showUnityModalProgress)
+			{
+				EditorUtility.DisplayProgressBar(operationTitle, description, progress);
+			}
 		}
 
 		public void SetManifestId(string id)

package/Editor/LibraryService.cs

@@ -78,11 +78,34 @@ namespace Beamable.Editor
 		{
 		}
 
-		public void OpenDocumentation(LightbeamSampleInfo lb)
+		public void OpenDocumentation(string page)
 		{
-			Application.OpenURL(lb.docsUrl);
+			var packageFile = $"Packages/{BeamablePackages.BeamablePackageName}/package.json";
+			if (!File.Exists(packageFile)) 
+				return;
+
+			var json = File.ReadAllText(packageFile);
+			var dict = (ArrayDict)Json.Deserialize(json);
+			if (!dict.TryGetValue("documentationUrl", out var docsURL))
+				return;
+			
+			Application.OpenURL($"{docsURL}{page}");
 		}
 
+		public void OpenDocumentation(LightbeamSampleInfo lb)
+		{
+			var packageFile = $"Packages/{BeamablePackages.BeamablePackageName}/package.json";
+			if (!File.Exists(packageFile)) 
+				return;
+
+			var json = File.ReadAllText(packageFile);
+			var dict = (ArrayDict)Json.Deserialize(json);
+			if (!dict.TryGetValue("documentationUrl", out var docsURL))
+				return;
+			
+			Application.OpenURL($"{docsURL}{lb.docsUrl}");
+		}
+		
 		public void OpenSample(LightbeamSampleInfo lb)
 		{
 			var needsRefresh = false;

package/Editor/Modules/Content/UI/ContentObjectEditor.cs

@@ -374,10 +374,11 @@ namespace Beamable.Editor.Content.UI
 				rect = new Rect(rect.x, rect.y - 6, rect.width, rect.height);
 				GUI.Box(new Rect(0, rect.y, contextWidth, rect.height), "", "In BigTitle Post");
 
-				EditorGUI.SelectableLabel(rect, $"Checksum: {ContentUtils.ComputeChecksum(contentObject)}", checksumStyle);
+				EditorGUI.SelectableLabel(rect, $"Checksum: {contentObject.GetEditorDataChecksum()}", checksumStyle);
 			}
-
+			
 			base.OnInspectorGUI();
+			contentObject.CheckForNonDetectedChanges();
 		}
 
 		public string GetTagString(string[] tags)

package/Editor/Server/MicroserviceConfiguration.cs

@@ -58,6 +58,9 @@ namespace Beamable.Server.Editor
 		[Tooltip("For each service, a boolean to control if the client code should be generated automatically when the service is built. By default, services will autogenerate, so if the key does not exist, the service will autogenerate a client. ")]
 		public SerializableDictionaryStringToBool AutoGenerateClientOnBuilds =
 			new SerializableDictionaryStringToBool();
+		
+		[Tooltip("Optional value to set the Max Parallel Build Count for Microservices during release plan build")]
+		public Optional<int> MaxParallelBuildCount =  new Optional<int>() { Value = 8, HasValue = false};
 
 	}
 	

package/Editor/Server/UI/PublishWindow/UsamPublishWindow.cs

@@ -113,8 +113,12 @@ namespace Beamable.Editor.Microservice.UI2.PublishWindow
 				_planArgs = new DeploymentPlanArgs
 				{
 					runHealthChecks = config.EnablePrePublishHealthCheck, 
-					merge = config.EnableMergeDeploy
+					merge = config.EnableMergeDeploy,
 				};
+				if (config.MaxParallelBuildCount.HasValue)
+				{
+					_planArgs.maxParallelCount = config.MaxParallelBuildCount.Value;
+				}
 				_planCommand = _ctx.Cli.DeploymentPlan(_planArgs);
 				_planCommand.OnProgressPlanReleaseProgress(cb =>
 				{

package/Editor/Server/Usam/UsamService_GenerateClient.cs

@@ -56,7 +56,12 @@ namespace Beamable.Server.Editor.Usam
 			//  ensures we have the latest client generated
 			AddLog(service.beamoId, CliLogMessage.FromStringNow(" building latest code..."));
 
-			await Build(new ProjectBuildArgs {ids = idArr, stopReason = "\"Stopped service to generate client code.\""});
+			var projectBuildArgs = new ProjectBuildArgs {ids = idArr, stopReason = "\"Stopped service to generate client code.\""};
+			if (_config.MaxParallelBuildCount.HasValue)
+			{
+				projectBuildArgs.maxParallelCount = _config.MaxParallelBuildCount.Value;
+			}
+			await Build(projectBuildArgs);
 
 			AddLog(service.beamoId, CliLogMessage.FromStringNow(" generating client code..."));
 			if (!ShouldServiceAutoGenerateClient(service.beamoId))

package/Editor/UI/AccountWindow/AccountWindow_SignedIn.cs

@@ -170,7 +170,7 @@ namespace Beamable.Editor.Accounts
 						if (_onQuitAction == null)
 						{
 							_onQuitAction = BeamLibraryWindow.Init;
-							_onQuitName = "Open Library";
+							_onQuitName = "Open Samples";
 						}
 
 						var clickedLibrary = BeamGUI.PrimaryButton(new GUIContent(_onQuitName), allowEnterKeyToClick: true);

package/Editor/UI/ContentWindow/ContentWindow.cs

@@ -31,6 +31,7 @@ namespace Beamable.Editor.UI.ContentWindow
 		private ContentConfiguration _contentConfiguration;
 		private Vector2 _horizontalScrollPosition;
 		private int _lastManifestChangedCount;
+		private int _lastProgressUpdateVersion;
 		private EditorGUISplitView _mainSplitter;
 
 		static ContentWindow()
@@ -109,6 +110,12 @@ namespace Beamable.Editor.UI.ContentWindow
 				ReloadData();
 				Repaint(); 
 			}
+
+			if (_contentService != null && _contentService.ProgressUpdateVersion != _lastProgressUpdateVersion)
+			{
+				_lastProgressUpdateVersion = _contentService.ProgressUpdateVersion;
+				Repaint();
+			}
 		}
 
 		private void ReloadData()
@@ -119,7 +126,7 @@ namespace Beamable.Editor.UI.ContentWindow
 			
 			if(!_contentService.HasChangedContents && _windowStatus != ContentWindowStatus.SnapshotManager)
 			{
-				ChangeWindowStatus(ContentWindowStatus.Normal);
+				ChangeWindowStatusDelayed(ContentWindowStatus.Normal);
 			}
 		}
 

package/Editor/UI/ContentWindow/ContentWindow_ContentActions.cs

@@ -31,7 +31,7 @@ namespace Beamable.Editor.UI.ContentWindow
 		{
 			if (_contentService.HasConflictedContent || _contentService.HasInvalidContent || !_contentService.HasChangedContents)
 			{
-				ChangeWindowStatus(ContentWindowStatus.Normal);
+				ChangeWindowStatusDelayed(ContentWindowStatus.Normal);
 				return;
 			}
 			
@@ -43,7 +43,7 @@ namespace Beamable.Editor.UI.ContentWindow
 				{
 					_contentService.PublishContentsWithProgress().Then(_ =>
 					{
-						ChangeWindowStatus(ContentWindowStatus.Normal);
+						ChangeWindowStatusDelayed(ContentWindowStatus.Normal);
 					});
 				}
 			}
@@ -55,9 +55,9 @@ namespace Beamable.Editor.UI.ContentWindow
 		
 		private void DrawRevertPanel()
 		{
-			if (!_contentService.HasChangedContents)
+			if (!_contentService.HasChangedContents && !_contentService.CurrentProgress.IsActive)
 			{
-				ChangeWindowStatus(ContentWindowStatus.Normal);
+				ChangeWindowStatusDelayed(ContentWindowStatus.Normal);
 				return;
 			}
 			
@@ -69,7 +69,7 @@ namespace Beamable.Editor.UI.ContentWindow
 				{ 
 					_revertAction?.Invoke().Then(_ =>
 					{
-						ChangeWindowStatus(ContentWindowStatus.Normal);
+						ChangeWindowStatusDelayed(ContentWindowStatus.Normal);
 					});
 				}
 			}
@@ -195,7 +195,7 @@ namespace Beamable.Editor.UI.ContentWindow
 			GUILayout.FlexibleSpace();
 			if (BeamGUI.CancelButton("Back", GUILayout.Width(60)))
 			{
-				ChangeWindowStatus(ContentWindowStatus.Normal);
+				ChangeWindowStatusDelayed(ContentWindowStatus.Normal);
 			}
 		}
 		
@@ -240,26 +240,67 @@ namespace Beamable.Editor.UI.ContentWindow
 			EditorGUILayout.EndScrollView();
 			
 			EditorGUILayout.Space(12);
+
+			if (DrawContentOperationProgress())
+			{
+				EditorGUILayout.Space(12);
+			}
 			
 			var buttonsRect = EditorGUILayout.GetControlRect(GUILayout.ExpandWidth(true), GUILayout.Height(30f));
 			var buttonsRectController = new EditorGUIRectController(buttonsRect);
 			var primaryBtnContent = new GUIContent(buttonText);
 			var primaryBtnSize = GUI.skin.button.CalcSize(primaryBtnContent);
 			
-			if (BeamGUI.PrimaryButton(buttonsRectController.ReserveWidthFromRight(primaryBtnSize.x + BASE_PADDING * 2), primaryBtnContent))
+			if (BeamGUI.ShowDisabled(!_contentService.CurrentProgress.IsActive,
+			                         () => BeamGUI.PrimaryButton(buttonsRectController.ReserveWidthFromRight(primaryBtnSize.x + BASE_PADDING * 2), primaryBtnContent)))
 			{
 				onButtonClicked?.Invoke();
 			}
 			var cancelBtnContent = new GUIContent("Cancel");
 			var cancelBtnSize = GUI.skin.button.CalcSize(cancelBtnContent);
-			if (BeamGUI.CustomButton(buttonsRectController.ReserveWidthFromRight(cancelBtnSize.x + BASE_PADDING * 2), cancelBtnContent, BeamGUI.ColorizeButton(Color.gray)))
+			if (BeamGUI.ShowDisabled(!_contentService.CurrentProgress.IsActive,
+			                         () => BeamGUI.CustomButton(buttonsRectController.ReserveWidthFromRight(cancelBtnSize.x + BASE_PADDING * 2), cancelBtnContent, BeamGUI.ColorizeButton(Color.gray))))
 			{
-				ChangeWindowStatus(ContentWindowStatus.Normal);
+				ChangeWindowStatusDelayed(ContentWindowStatus.Normal);
 			}
 
 			EditorGUILayout.EndVertical();
 		}
 
+		/// <summary>
+		/// Draws the active content operation progress bar in the Content Manager action panel.
+		/// </summary>
+		/// <returns>True when progress UI was drawn and the caller should reserve spacing for it.</returns>
+		private bool DrawContentOperationProgress()
+		{
+			var progress = _contentService.CurrentProgress;
+			if (!progress.IsActive)
+			{
+				return false;
+			}
+
+			var progressAction = progress.Title == "Publish Contents" ? "published" : "synced";
+			var progressText = progress.TotalItems > 0
+				? $"{progress.ProcessedItems}/{progress.TotalItems} items {progressAction}"
+				: $"Preparing {progress.Title.ToLowerInvariant()}...";
+
+			if (!string.IsNullOrEmpty(progress.CurrentContentName))
+			{
+				progressText = $"{progressText} - {progress.CurrentContentName}";
+			}
+
+			EditorGUILayout.LabelField(progress.Title, EditorStyles.boldLabel);
+			var progressRect = EditorGUILayout.GetControlRect(GUILayout.ExpandWidth(true), GUILayout.Height(20));
+			EditorGUI.ProgressBar(progressRect, progress.Progress, progressText);
+
+			if (!string.IsNullOrEmpty(progress.Description))
+			{
+				EditorGUILayout.LabelField(progress.Description, _contentHeaderDescriptionStyle);
+			}
+
+			return true;
+		}
+
 		private void DrawChangedContents(float width,
 		                                 string headerName,
 		                                 Texture icon,

package/Editor/UI/ContentWindow/ContentWindow_Header.cs

@@ -119,7 +119,7 @@ namespace Beamable.Editor.UI.ContentWindow
 			{
 				if (BeamGUI.HeaderButton("Content Editor", BeamGUI.iconContentEditorIcon, width: 90, iconPadding: 2))
 				{
-					ChangeWindowStatus(ContentWindowStatus.Normal);
+					ChangeWindowStatusDelayed(ContentWindowStatus.Normal);
 				}
 			}
 			if (_windowStatus is ContentWindowStatus.Normal || _windowStatus is ContentWindowStatus.Validate)
@@ -260,6 +260,17 @@ namespace Beamable.Editor.UI.ContentWindow
 				Repaint();
 		}
 
+		/// <summary>
+		/// Defers Content Manager state changes until the current IMGUI event has finished.
+		/// </summary>
+		/// <remarks>
+		/// Some state transitions remove or add controls. Deferring them avoids mismatched layout groups during repaint.
+		/// </remarks>
+		private void ChangeWindowStatusDelayed(ContentWindowStatus windowStatus)
+		{
+			EditorApplication.delayCall += () => ChangeWindowStatus(windowStatus);
+		}
+
 		private void DrawLowBarHeader(Rect rect)
 		{
 			if (NeedsMigration) return;
@@ -420,27 +431,27 @@ namespace Beamable.Editor.UI.ContentWindow
 
 		private async Promise RevertAllContents()
 		{
-			await _contentService.SyncContentsWithProgress(true, true, true, true);
+			await _contentService.SyncContentsWithProgress(true, true, true, true, showUnityModalProgress: false);
 		}
 
 		private async Promise RevertModifiedContents()
 		{
-			await _contentService.SyncContentsWithProgress(true, false, false, false);
+			await _contentService.SyncContentsWithProgress(true, false, false, false, showUnityModalProgress: false);
 		}
 
 		private async Promise RevertConflictedContents()
 		{
-			await _contentService.SyncContentsWithProgress(false, false, true, false);
+			await _contentService.SyncContentsWithProgress(false, false, true, false, showUnityModalProgress: false);
 		}
 
 		private async Promise RevertDeletedContents()
 		{
-			await _contentService.SyncContentsWithProgress(false, false, false, true);
+			await _contentService.SyncContentsWithProgress(false, false, false, true, showUnityModalProgress: false);
 		}
 
 		private async Promise RevertAllNewContents()
 		{
-			await _contentService.SyncContentsWithProgress(false, true, false, false);
+			await _contentService.SyncContentsWithProgress(false, true, false, false, showUnityModalProgress: false);
 		}
 
 		

package/Editor/UI/ContentWindow/ContentWindow_ItemsPanel.cs

@@ -387,6 +387,9 @@ namespace Beamable.Editor.UI.ContentWindow
 			}
 			
 			var contentObject = CreateInstance(type) as ContentObject;
+			// Force Unity's serializer to instantiate all nested [Serializable] reference fields
+			// (e.g. Optional abd strings types) with proper default instances instead of leaving them null.
+			JsonUtility.FromJsonOverwrite(JsonUtility.ToJson(contentObject), contentObject);
 			string baseName = $"New_{itemType.Replace(".","_")}_";
 			int nextNumber = _contentService.GetContentsFromType(type)
 			                                .Select(item => item.Name)

package/Editor/UI/LibraryWindow/BeamLibraryWindow.cs

@@ -15,7 +15,7 @@ namespace Beamable.Editor.Library
 		{
 			WindowDefaultConfig = new BeamEditorWindowInitConfig()
 			{
-				Title = "Beam Library",
+				Title = "Beam Samples",
 				FocusOnShow = false,
 				DockPreferenceTypeName = typeof(SceneView).AssemblyQualifiedName,
 				RequireLoggedUser = true,
@@ -25,7 +25,7 @@ namespace Beamable.Editor.Library
 		[MenuItem(
 			Constants.MenuItems.Windows.Paths.MENU_ITEM_PATH_WINDOW_BEAMABLE + "/" +
 			Constants.Commons.OPEN + " " +
-			"Beam Library",
+			"Beam Samples",
 			priority = Constants.MenuItems.Windows.Orders.MENU_ITEM_PATH_WINDOW_PRIORITY_2
 		)]
 		public static async void Init() => _ = await GetFullyInitializedWindow();

package/Editor/UI/LibraryWindow/BeamLibraryWindow_Main.cs

@@ -8,28 +8,7 @@ namespace Beamable.Editor.Library
 	{
 		void DrawMain()
 		{
-			DrawHeader();
 			DrawSampleSection();
 		}
-
-		void DrawHeader()
-		{
-			BeamGUI.DrawHeaderSection(this, ActiveContext,
-			                          drawTopBarGui: () =>
-			                          {
-				                          // there aren't really any options that make sense yet.
-			                          }, 
-			                          drawLowBarGui: () =>
-			                          {
-			                          }, 
-			                          onClickedRefresh: () =>
-			                          {
-				                          library.Reload();
-			                          },
-			                          onClickedHelp: () =>
-			                          {
-				                          Application.OpenURL(DocsPageHelper.GetUnityDocsPageUrl("unity/samples/lightbeam/", EditorConstants.UNITY_CURRENT_DOCS_VERSION));
-			                          });
-		}
 	}
 }