com.beamable 5.0.1 → 5.1.0-PREVIEW.RC2

package/Common/Runtime/SmallerJSON/SmallerJSON.FromString.cs

@@ -1,5 +1,5 @@
-// this file was copied from nuget package Beamable.Common@7.0.1
-// https://www.nuget.org/packages/Beamable.Common/7.0.1
+// this file was copied from nuget package Beamable.Common@7.2.0-PREVIEW.RC2
+// https://www.nuget.org/packages/Beamable.Common/7.2.0-PREVIEW.RC2
 
 /*
  * Simplified fork of MiniJSON optimized to minimize heap allocations

package/Common/Runtime/SmallerJSON/SmallerJSON.cs

@@ -1,5 +1,5 @@
-// this file was copied from nuget package Beamable.Common@7.0.1
-// https://www.nuget.org/packages/Beamable.Common/7.0.1
+// this file was copied from nuget package Beamable.Common@7.2.0-PREVIEW.RC2
+// https://www.nuget.org/packages/Beamable.Common/7.2.0-PREVIEW.RC2
 
 /*
  * Simplified fork of MiniJSON optimized to minimize heap allocations
@@ -80,6 +80,35 @@ namespace Beamable.Serialization.SmallerJSON
 				return obj;
 			}
 		}
+		
+		/// <summary>
+		/// Deserialize JSON into a concrete type. Unlike Unity JsonUtility, this supports
+		/// custom semantic wrapper types (ex: types implementing IBeamSemanticType<T>)
+		/// even when JSON contains only the primitive token (string/number).
+		/// </summary>
+		public static T Deserialize<T>(string json)
+		{
+			return (T)Deserialize(json, typeof(T));
+		}
+
+		/// <summary>
+		/// Deserialize JSON into a concrete type (runtime type overload).
+		/// </summary>
+		public static object Deserialize(string json, Type targetType)
+		{
+			if (json == null) return null;
+
+			// First parse into SmallerJSON's object model (ArrayDict/List/primitives).
+			object root;
+			using (var parser = new StringBasedParser(json))
+			{
+				root = parser.ParseValue();
+			}
+
+			// Then materialize into the requested type.
+			return ObjectMapper.ConvertToType(root, targetType);
+		}
+		
 
 		public static bool IsValidJson(string strInput)
 		{
@@ -1052,5 +1081,200 @@ namespace Beamable.Serialization.SmallerJSON
 				}
 			}
 		}
+		
+		private static class ObjectMapper
+		{
+			private static readonly Type SerializeFieldType = typeof(SerializeField);
+
+			// NOTE: We cannot reference Beamable.Common.Semantics directly from this folder.
+			// We detect semantic types via reflection by interface full name instead
+			private const string BeamSemanticInterfaceFullName = "Beamable.Common.Semantics.IBeamSemanticType`1";
+
+			public static object ConvertToType(object node, Type targetType)
+			{
+				if (targetType == null) throw new ArgumentNullException(nameof(targetType));
+
+				// Null handling
+				if (node == null)
+				{
+					targetType = Nullable.GetUnderlyingType(targetType) ?? targetType;
+					return targetType.IsValueType ? Activator.CreateInstance(targetType) : null;
+				}
+
+				// Unwrap nullable
+				targetType = Nullable.GetUnderlyingType(targetType) ?? targetType;
+
+				// Semantic types: construct from primitive JSON tokens
+				if (TryGetSemanticPrimitiveType(targetType, out var primitiveType))
+				{
+					return ConstructSemantic(targetType, primitiveType, node);
+				}
+
+				// Direct assign
+				if (targetType.IsInstanceOfType(node))
+				{
+					return node;
+				}
+
+				// Enums
+				if (targetType.IsEnum)
+				{
+					if (node is string s) return Enum.Parse(targetType, s, ignoreCase: true);
+					if (node is long l) return Enum.ToObject(targetType, (int)l);
+				}
+
+				// Common scalars
+				if (targetType == typeof(string)) return node.ToString();
+				if (targetType == typeof(bool)) return Convert.ToBoolean(node);
+				if (targetType == typeof(long)) return Convert.ToInt64(node);
+				if (targetType == typeof(int)) return Convert.ToInt32(node);
+				if (targetType == typeof(double)) return Convert.ToDouble(node);
+				if (targetType == typeof(float)) return Convert.ToSingle(node);
+				if (targetType == typeof(decimal)) return Convert.ToDecimal(node);
+
+				// Dictionaries (only generic Dictionary<string, TValue> supported here)
+				if (typeof(IDictionary).IsAssignableFrom(targetType) && targetType.IsGenericType)
+				{
+					var genArgs = targetType.GetGenericArguments();
+					if (genArgs.Length == 2 && genArgs[0] == typeof(string) && node is ArrayDict dictNode)
+					{
+						var valueType = genArgs[1];
+						var dict = (IDictionary)Activator.CreateInstance(targetType);
+						foreach (var kvp in dictNode)
+						{
+							dict[kvp.Key] = ConvertToType(kvp.Value, valueType);
+						}
+						return dict;
+					}
+				}
+
+				// Arrays
+				if (targetType.IsArray && node is IList listNodeForArray)
+				{
+					var elemType = targetType.GetElementType();
+					var arr = Array.CreateInstance(elemType!, listNodeForArray.Count);
+					for (int i = 0; i < listNodeForArray.Count; i++)
+					{
+						arr.SetValue(ConvertToType(listNodeForArray[i], elemType!), i);
+					}
+					return arr;
+				}
+
+				// Lists
+				if (typeof(IList).IsAssignableFrom(targetType) && node is IList listNode)
+				{
+					var elemType = targetType.IsGenericType ? targetType.GetGenericArguments()[0] : typeof(object);
+					var list = (IList)Activator.CreateInstance(targetType);
+					foreach (var elem in listNode)
+					{
+						list.Add(ConvertToType(elem, elemType));
+					}
+					return list;
+				}
+
+				// POCO object
+				if (node is ArrayDict objNode)
+				{
+					var instance = Activator.CreateInstance(targetType);
+
+					// Mirror existing Serializer rules: fields only, allow [SerializeField] privates,
+					// skip [NonSerialized] fields.
+					var fields = targetType.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
+					for (int i = 0; i < fields.Length; i++)
+					{
+						var field = fields[i];
+
+						var hasSerializeField = field.GetCustomAttribute(SerializeFieldType) != null;
+						var canBeSerialized = (hasSerializeField || !field.IsNotSerialized);
+						if (!canBeSerialized) continue;
+
+						if (!objNode.TryGetValue(field.Name, out var rawValue)) continue;
+
+						var converted = ConvertToType(rawValue, field.FieldType);
+						field.SetValue(instance, converted);
+					}
+
+					// If the target uses Unity callbacks, respect them (parity with existing Serializer behavior)
+					if (instance is ISerializationCallbackReceiver receiver)
+					{
+						receiver.OnAfterDeserialize();
+					}
+
+					return instance;
+				}
+
+				throw new InvalidOperationException(
+					$"SmallerJSON cannot convert node type [{node.GetType().FullName}] to [{targetType.FullName}].");
+			}
+
+			private static bool TryGetSemanticPrimitiveType(Type semanticType, out Type primitiveType)
+			{
+				var iface = semanticType.GetInterfaces()
+					.FirstOrDefault(i => i.IsGenericType && i.GetGenericTypeDefinition().FullName == BeamSemanticInterfaceFullName);
+
+				if (iface == null)
+				{
+					primitiveType = null;
+					return false;
+				}
+
+				primitiveType = iface.GetGenericArguments()[0];
+				return true;
+			}
+
+			private static object ConstructSemantic(Type semanticType, Type primitiveType, object node)
+			{
+				// Prefer ctor(string) when JSON is a string. Many long-backed semantic types accept string too
+				// and preserve formatting (leading zeros etc) or validate (ServiceName).
+				if (node is string s)
+				{
+					var stringCtor = semanticType.GetConstructor(new[] { typeof(string) });
+					if (stringCtor != null) return stringCtor.Invoke(new object[] { s });
+
+					if (primitiveType == typeof(long))
+					{
+						if (!long.TryParse(s, System.Globalization.NumberStyles.Integer,
+								System.Globalization.CultureInfo.InvariantCulture, out var parsed))
+						{
+							throw new FormatException($"Cannot parse '{s}' as long for semantic type [{semanticType.FullName}].");
+						}
+
+						var longCtor = semanticType.GetConstructor(new[] { typeof(long) });
+						if (longCtor != null) return longCtor.Invoke(new object[] { parsed });
+					}
+
+					throw new MissingMethodException(
+						$"Semantic type [{semanticType.FullName}] has no public ctor(string) and cannot be built from JSON string.");
+				}
+
+				// If JSON is numeric and semantic primitive is long
+				if (primitiveType == typeof(long))
+				{
+					var l = Convert.ToInt64(node, System.Globalization.CultureInfo.InvariantCulture);
+					var longCtor = semanticType.GetConstructor(new[] { typeof(long) });
+					if (longCtor != null) return longCtor.Invoke(new object[] { l });
+
+					// Some semantic types might only expose ctor(string); allow numeric -> string as fallback.
+					var stringCtor = semanticType.GetConstructor(new[] { typeof(string) });
+					if (stringCtor != null) return stringCtor.Invoke(new object[] { l.ToString(System.Globalization.CultureInfo.InvariantCulture) });
+
+					throw new MissingMethodException($"Semantic type [{semanticType.FullName}] must have ctor(long) or ctor(string).");
+				}
+
+				// If semantic primitive is string, coerce to string
+				if (primitiveType == typeof(string))
+				{
+					var stringCtor = semanticType.GetConstructor(new[] { typeof(string) });
+					if (stringCtor == null)
+						throw new MissingMethodException($"Semantic type [{semanticType.FullName}] must have ctor(string).");
+
+					return stringCtor.Invoke(new object[] { node.ToString() });
+				}
+
+				throw new NotSupportedException(
+					$"Semantic type [{semanticType.FullName}] uses unsupported primitive [{primitiveType.FullName}].");
+			}
+		}
+		
 	}
 }

package/Common/Runtime/Spew/Logger.cs

@@ -1,5 +1,5 @@
-// this file was copied from nuget package Beamable.Common@7.0.1
-// https://www.nuget.org/packages/Beamable.Common/7.0.1
+// this file was copied from nuget package Beamable.Common@7.2.0-PREVIEW.RC2
+// https://www.nuget.org/packages/Beamable.Common/7.2.0-PREVIEW.RC2
 
 //#define PREPEND_SPEW_METADATA
 // With PREPEND_SPEW_METADATA defined, all spew logs will have frame # and time prepended.

package/Common/Runtime/Spew/SpewLoggerAttribute.cs

@@ -1,5 +1,5 @@
-// this file was copied from nuget package Beamable.Common@7.0.1
-// https://www.nuget.org/packages/Beamable.Common/7.0.1
+// this file was copied from nuget package Beamable.Common@7.2.0-PREVIEW.RC2
+// https://www.nuget.org/packages/Beamable.Common/7.2.0-PREVIEW.RC2
 
 using System;
 using System.Diagnostics;

package/Common/Runtime/Trie.cs

@@ -1,5 +1,5 @@
-// this file was copied from nuget package Beamable.Common@7.0.1
-// https://www.nuget.org/packages/Beamable.Common/7.0.1
+// this file was copied from nuget package Beamable.Common@7.2.0-PREVIEW.RC2
+// https://www.nuget.org/packages/Beamable.Common/7.2.0-PREVIEW.RC2
 
 using System;
 using System.Collections.Generic;

package/Common/Runtime/TypeExtensions.cs

@@ -1,5 +1,5 @@
-// this file was copied from nuget package Beamable.Common@7.0.1
-// https://www.nuget.org/packages/Beamable.Common/7.0.1
+// this file was copied from nuget package Beamable.Common@7.2.0-PREVIEW.RC2
+// https://www.nuget.org/packages/Beamable.Common/7.2.0-PREVIEW.RC2
 
 
 using System;

package/Common/Runtime/Util/BeamAssemblyVersionUtil.cs

@@ -1,5 +1,5 @@
-// this file was copied from nuget package Beamable.Common@7.0.1
-// https://www.nuget.org/packages/Beamable.Common/7.0.1
+// this file was copied from nuget package Beamable.Common@7.2.0-PREVIEW.RC2
+// https://www.nuget.org/packages/Beamable.Common/7.2.0-PREVIEW.RC2
 
 using Beamable.Common.Spew;
 using System;

package/Common/Runtime/Util/BeamFileUtil.cs

@@ -1,5 +1,5 @@
-// this file was copied from nuget package Beamable.Common@7.0.1
-// https://www.nuget.org/packages/Beamable.Common/7.0.1
+// this file was copied from nuget package Beamable.Common@7.2.0-PREVIEW.RC2
+// https://www.nuget.org/packages/Beamable.Common/7.2.0-PREVIEW.RC2
 
 using System;
 using System.IO;

package/Common/Runtime/Util/DocsPageHelper.cs

@@ -1,5 +1,5 @@
-// this file was copied from nuget package Beamable.Common@7.0.1
-// https://www.nuget.org/packages/Beamable.Common/7.0.1
+// this file was copied from nuget package Beamable.Common@7.2.0-PREVIEW.RC2
+// https://www.nuget.org/packages/Beamable.Common/7.2.0-PREVIEW.RC2
 
 namespace Beamable.Common.Util
 {

package/Common/Runtime/Util/NaturalStringComparer.cs

@@ -1,5 +1,5 @@
-// this file was copied from nuget package Beamable.Common@7.0.1
-// https://www.nuget.org/packages/Beamable.Common/7.0.1
+// this file was copied from nuget package Beamable.Common@7.2.0-PREVIEW.RC2
+// https://www.nuget.org/packages/Beamable.Common/7.2.0-PREVIEW.RC2
 
 using System.Collections.Generic;
 

package/Editor/BeamCli/BeamCliUtil.cs

@@ -135,34 +135,30 @@ namespace Beamable.Editor.BeamCli
 					return true;
 				}
 
-				var proc = new Process();
 				var installCommand = $"tool install Beamable.Tools --create-manifest-if-needed --allow-downgrade";
 
-				if (Application.isBatchMode)
+				// Only add the local folder feed for the local dev version (0.0.123.*). For a published
+				// version, installing from a local folder feed extracts into the global packages folder
+				// without copying the .nupkg, which then crashes finalization; let it resolve from nuget.org.
+				if (Application.isBatchMode && BeamableEnvironment.NugetPackageVersion.ToString().StartsWith("0.0.123"))
 				{
 					installCommand += " --add-source BeamableNugetSource ";
 				}
 
-				if (!BeamableEnvironment.NugetPackageVersion.ToString().Equals("0.0.123"))
+				// Lowercase the version: dotnet tool install builds the global-packages path from the raw --version string, so an uppercase pre-release label (7.2.0-PREVIEW.RC1) mismatches NuGet's lowercased cache folder on case-sensitive (Linux) filesystems.
+				var versionArg = BeamableEnvironment.NugetPackageVersion.ToString().ToLowerInvariant();
+				if (!versionArg.Equals("0.0.123"))
 				{
-					installCommand += $" --version {BeamableEnvironment.NugetPackageVersion}";
+					installCommand += $" --version {versionArg}";
 				}
 				else
 				{
-					installCommand += $" --version {BeamableEnvironment.NugetPackageVersion}.*";
+					installCommand += $" --version {versionArg}.*";
 				}
 
-				proc.StartInfo = new ProcessStartInfo
-				{
-					FileName = "dotnet",
-					WorkingDirectory = Path.GetFullPath("."),
-					Arguments = installCommand,
-					UseShellExecute = false,
-					CreateNoWindow = true,
-					RedirectStandardOutput = true,
-					RedirectStandardError = true
-				};
-				proc.StartInfo.Environment.Add("DOTNET_CLI_UI_LANGUAGE", "en");
+				var proc = NewInstallProcess();
+				Debug.Log($"[BeamCLI] Installing Beam CLI version [{BeamableEnvironment.NugetPackageVersion}]. " +
+				          $"Command: [dotnet {installCommand}]. A first-time install with a cold NuGet cache can be slow while packages download.");
 				TryRunWithTimeout(1);
 
 				const string errorGuide =
@@ -170,6 +166,22 @@ namespace Beamable.Editor.BeamCli
 
 				var output = proc.StandardOutput.ReadToEnd();
 				var error = proc.StandardError.ReadToEnd();
+
+				// On some SDKs the local tool installer caches the package without its .nupkg and then crashes finalizing it. Only when we see that exact failure, pre-download the package via a normal restore (which keeps the .nupkg) and retry once, so unaffected SDKs never pay the cost.
+				var installLog = (output ?? string.Empty) + (error ?? string.Empty);
+				if (proc.ExitCode != 0 && installLog.Contains(".nupkg") &&
+				    (installLog.Contains("Could not find file") || installLog.Contains("FileNotFoundException")))
+				{
+					Debug.LogWarning("[BeamCLI] Install failed with a missing .nupkg in the global packages cache (known local tool-install issue). Healing the cache and pre-downloading the package, then retrying once.");
+					HealCorruptGlobalPackagesEntry();
+					WarmGlobalPackagesCache();
+
+					proc = NewInstallProcess();
+					TryRunWithTimeout(1);
+					output = proc.StandardOutput.ReadToEnd();
+					error = proc.StandardError.ReadToEnd();
+				}
+
 				if (!string.IsNullOrWhiteSpace(error) || proc.ExitCode != 0)
 				{
 					StringBuilder message = new StringBuilder("Unable to install BeamCLI");
@@ -180,6 +192,7 @@ namespace Beamable.Editor.BeamCli
 
 					message.AppendLine($"Error: {error}");
 					message.Append(errorGuide);
+					Debug.Log("Failed Install Command: " + installCommand);
 					Debug.LogError(message.ToString());
 					var tryAgainButtonInfo = new OptionDialogWindow.ButtonInfo()
 					{
@@ -218,16 +231,55 @@ namespace Beamable.Editor.BeamCli
 
 				return proc.ExitCode == 0;
 
+				Process NewInstallProcess()
+				{
+					var p = new Process
+					{
+						StartInfo = new ProcessStartInfo
+						{
+							FileName = "dotnet",
+							WorkingDirectory = Path.GetFullPath("."),
+							Arguments = installCommand,
+							UseShellExecute = false,
+							CreateNoWindow = true,
+							RedirectStandardOutput = true,
+							RedirectStandardError = true
+						}
+					};
+					p.StartInfo.Environment.Add("DOTNET_CLI_UI_LANGUAGE", "en");
+					return p;
+				}
+
 				bool TryRunWithTimeout(int currentTry)
 				{
+					var timeoutMs = 30 * 1000 * currentTry;
+					Debug.Log($"[BeamCLI] Install attempt {currentTry} starting (timeout {timeoutMs / 1000}s)...");
+					var stopwatch = Stopwatch.StartNew();
 					proc.Start();
-					if (proc.WaitForExit(10 * 1000 * currentTry))
+					if (proc.WaitForExit(timeoutMs))
 					{
+						Debug.Log($"[BeamCLI] Install attempt {currentTry} exited with code {proc.ExitCode} after {stopwatch.Elapsed.TotalSeconds:0.#}s.");
 						return true;
 					}
 
+					// Kill the still-running process before retrying; a concurrent retry corrupts the NuGet cache (a version folder left without its .nupkg), which then fails every later restore.
 					Debug.LogError(
-						"dotnet tool install command did not finish fast enough; timed out. Trying again with longer timeout");
+						$"[BeamCLI] Install attempt {currentTry} did not finish within {timeoutMs / 1000}s. " +
+						"Killing the dotnet process before retrying to avoid corrupting the NuGet cache.");
+					try
+					{
+						if (!proc.HasExited)
+						{
+							proc.Kill();
+						}
+						proc.WaitForExit();
+						Debug.Log($"[BeamCLI] Killed the timed-out dotnet process from attempt {currentTry}.");
+					}
+					catch (Exception killEx)
+					{
+						Debug.LogWarning($"[BeamCLI] Failed to kill the timed-out dotnet install process: {killEx.Message}");
+					}
+
 					const int maxRetries = 5;
 					if (currentTry > maxRetries)
 					{
@@ -245,9 +297,104 @@ namespace Beamable.Editor.BeamCli
 						return false;
 					}
 
+					Debug.Log($"[BeamCLI] Retrying install with a longer timeout (attempt {currentTry + 1}).");
 					return TryRunWithTimeout(++currentTry);
 
 				}
+
+				void WarmGlobalPackagesCache()
+				{
+					var version = BeamableEnvironment.NugetPackageVersion.ToString();
+					// The local dev flow installs 0.0.123.* from the local folder feed, which already
+					// lands the .nupkg in the cache, so there is nothing to warm (and it is not on nuget.org).
+					if (version.StartsWith("0.0.123"))
+					{
+						return;
+					}
+
+					try
+					{
+						var warmDir = Path.Combine(Path.GetFullPath("Library/BeamableEditor"), "cli-cache-warm");
+						Directory.CreateDirectory(warmDir);
+						var csprojPath = Path.Combine(warmDir, "warm.csproj");
+						File.WriteAllText(csprojPath,
+							"<Project Sdk=\"Microsoft.NET.Sdk\">\n" +
+							"  <PropertyGroup><TargetFramework>net8.0</TargetFramework></PropertyGroup>\n" +
+							$"  <ItemGroup><PackageDownload Include=\"Beamable.Tools\" Version=\"[{version}]\" /></ItemGroup>\n" +
+							"</Project>\n");
+
+						var warm = new Process
+						{
+							StartInfo = new ProcessStartInfo
+							{
+								FileName = "dotnet",
+								WorkingDirectory = warmDir,
+								Arguments = $"restore \"{csprojPath}\"",
+								UseShellExecute = false,
+								CreateNoWindow = true,
+								RedirectStandardOutput = true,
+								RedirectStandardError = true
+							}
+						};
+						warm.StartInfo.Environment.Add("DOTNET_CLI_UI_LANGUAGE", "en");
+						Debug.Log($"[BeamCLI] Warming the NuGet cache with Beamable.Tools [{version}] via PackageDownload restore...");
+						warm.Start();
+						if (!warm.WaitForExit(120 * 1000))
+						{
+							try { if (!warm.HasExited) warm.Kill(); }
+							catch { /* ignore */ }
+							Debug.LogWarning("[BeamCLI] Cache-warm restore timed out; continuing to the install anyway.");
+							return;
+						}
+
+						var output = warm.StandardOutput.ReadToEnd();
+						var error = warm.StandardError.ReadToEnd();
+						Debug.Log($"[BeamCLI] Cache-warm restore exited with code {warm.ExitCode}. {output} {error}");
+					}
+					catch (Exception warmEx)
+					{
+						Debug.LogWarning($"[BeamCLI] Cache-warm failed (continuing to the install anyway): {warmEx.Message}");
+					}
+				}
+
+				void HealCorruptGlobalPackagesEntry()
+				{
+					try
+					{
+						var packageId = "beamable.tools";
+						var version = BeamableEnvironment.NugetPackageVersion.ToString().ToLowerInvariant();
+						var globalPackages = System.Environment.GetEnvironmentVariable("NUGET_PACKAGES");
+						if (string.IsNullOrEmpty(globalPackages))
+						{
+							var home = System.Environment.GetEnvironmentVariable("HOME");
+							if (string.IsNullOrEmpty(home))
+							{
+								home = System.Environment.GetFolderPath(System.Environment.SpecialFolder.UserProfile);
+							}
+							globalPackages = Path.Combine(home, ".nuget", "packages");
+						}
+
+						var packageDir = Path.Combine(globalPackages, packageId, version);
+						if (!Directory.Exists(packageDir))
+						{
+							Debug.Log($"[BeamCLI] No pre-existing global-packages entry at [{packageDir}].");
+							return;
+						}
+
+						var nupkgCount = Directory.GetFiles(packageDir, "*.nupkg").Length;
+						var totalFiles = Directory.GetFiles(packageDir, "*", SearchOption.AllDirectories).Length;
+						Debug.Log($"[BeamCLI] Found global-packages entry [{packageDir}]: {nupkgCount} .nupkg, {totalFiles} total files.");
+						if (nupkgCount == 0)
+						{
+							Debug.LogWarning($"[BeamCLI] Entry [{packageDir}] is missing its .nupkg (corrupt). Deleting it so the install can re-download a complete copy.");
+							Directory.Delete(packageDir, true);
+						}
+					}
+					catch (Exception healEx)
+					{
+						Debug.LogWarning($"[BeamCLI] Auto-heal of the global-packages cache failed: {healEx.Message}");
+					}
+				}
 			}
 		}
 	}

package/Editor/BeamCli/BeamCommand.cs

@@ -444,9 +444,6 @@ namespace Beamable.Editor.BeamCli
 						{
 							CliLogger.Log("stdout", args.Data, System.Environment.NewLine + System.Environment.NewLine,
 							              _command);
-						});
-						_dispatcher.Schedule(() =>
-						{
 							try
 							{
 								ProcessStandardOut(args.Data);
@@ -469,9 +466,6 @@ namespace Beamable.Editor.BeamCli
 						{
 							CliLogger.Log("stderr", args.Data, System.Environment.NewLine + System.Environment.NewLine,
 							              _command);
-						});
-						_dispatcher.Schedule(() =>
-						{
 							try
 							{
 								ProcessStandardErr(args.Data);

package/Editor/BeamCli/BeamWebCommand.cs

@@ -135,6 +135,22 @@ namespace Beamable.Editor.BeamCli
 			_serverCommand = null;
 		}
 
+		public void InvalidateServer(Exception cause)
+		{
+			// Marshal back to the editor coroutine thread — port, _serverCommand,
+			// and discoveryRequest are all touched by ServerDiscoveryLoop and
+			// shouldn't race with an async continuation.
+			dispatcher.Schedule(() =>
+			{
+				_history.AddServerEvent(
+					$"Server invalidated: {cause.GetType().Name}: {cause.Message}");
+
+				KillServer();
+				port = _options.startPortOverride.GetOrElse(8432);
+				discoveryRequest++;
+			});
+		}
+
 		public string GetServerProcess()
 		{
 			
@@ -399,8 +415,8 @@ namespace Beamable.Editor.BeamCli
 			{
 				if (!_cts.IsCancellationRequested)
 				{
-					var client = new HttpClient() {Timeout = TimeSpan.FromDays(7),};
-					var sendTask = client.SendAsync(req, HttpCompletionOption.ResponseHeadersRead);
+					using var client = new HttpClient() {Timeout = TimeSpan.FromDays(7),};
+					var sendTask = client.SendAsync(req, HttpCompletionOption.ResponseHeadersRead, _cts.Token);
 					_history.AddCustomLog(id, "[Unity] sent request...");
 
 					using HttpResponseMessage response = await sendTask;
@@ -420,13 +436,10 @@ namespace Beamable.Editor.BeamCli
 						}
 
 						readTask = reader.ReadLineAsync();
-						while (!readTask.IsCompleted)
+						var cancelTcs = new TaskCompletionSource<bool>();
+						using (_cts.Token.Register(() => cancelTcs.TrySetResult(true)))
 						{
-							await Task.WhenAny(readTask, Task.Delay(50));
-							if (_cts.Token.IsCancellationRequested)
-							{
-								break;
-							}
+							await Task.WhenAny(readTask, cancelTcs.Task);
 						}
 						if (_cts.Token.IsCancellationRequested)
 						{
@@ -464,6 +477,15 @@ namespace Beamable.Editor.BeamCli
 				}
 
 			}
+			catch (Exception ex) when (IsTransportFailure(ex) && !_cts.IsCancellationRequested)
+			{
+				// The loopback connection to the CLI server is unhealthy
+				// (server died, port stale, half-closed socket). Tear down
+				// the cached server state so the next attempt rediscovers
+				// before we keep hammering a dead endpoint.
+				_factory.InvalidateServer(ex);
+				throw;
+			}
 			finally
 			{
 				_history.AddCustomLog(id, "[Unity] ending...");
@@ -484,6 +506,14 @@ namespace Beamable.Editor.BeamCli
 			_cts.Cancel();
 		}
 
+		private static bool IsTransportFailure(Exception ex)
+		{
+			return ex is HttpRequestException
+			       || ex is SocketException
+			       || ex is ObjectDisposedException
+			       || ex is IOException;
+		}
+
 		public IBeamCommand On<T>(Func<ReportDataPointDescription, bool> predicate, Action<ReportDataPoint<T>> cb)
 		{
 			On(desc =>