app.hypergames.hypersdk 1.8.13 → 1.8.14

package/Editor/Scripts/Build/HyperBuildPipeline.cs

@@ -0,0 +1,840 @@
+#if UNITY_EDITOR
+using System;
+using System.IO;
+using UnityEditor;
+using UnityEditor.Build;
+using UnityEditor.Build.Reporting;
+using UnityEditor.SceneManagement;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+using Hyper.Internal;
+
+namespace Hyper.Editor
+{
+    internal enum HyperBuildProfile
+    {
+        Development,
+        Release
+    }
+
+    internal sealed class HyperBuildRequest
+    {
+        public HyperBuildProfile Profile { get; set; }
+        public string OutputPath { get; set; } = "";
+        public bool CleanOutputFolder { get; set; } = true;
+        public bool OpenOutputFolder { get; set; } = false;
+        public bool IsCliBuild { get; set; } = false;
+    }
+
+    internal sealed class HyperBuildResult
+    {
+        public bool Succeeded { get; set; }
+        public BuildResult BuildResult { get; set; } = BuildResult.Unknown;
+        public string OutputPath { get; set; } = "";
+        public string Message { get; set; } = "";
+        public long TotalSizeBytes { get; set; }
+    }
+
+    internal static class HyperBuildPipeline
+    {
+        internal static HyperGameContentConfig _gameContentConfig;
+        internal static HyperSDKSettings _sdkSettings;
+        private const string ReleaseDefine = "HYPER_RELEASE_BUILD";
+        private const string DevelopmentDefine = "HYPER_DEVELOPMENT_BUILD";
+
+        private struct BuildSettingsSnapshot
+        {
+            public bool HasCodeOptimization;
+            public object CodeOptimizationValue;
+
+            public bool HasDebugSymbolMode;
+            public object DebugSymbolModeValue;
+
+            public bool HasExceptionSupport;
+            public WebGLExceptionSupport ExceptionSupportValue;
+
+            public bool HasIl2CppCodeGeneration;
+            public Il2CppCodeGeneration Il2CppCodeGenerationValue;
+        }
+
+        internal static HyperBuildResult Build(HyperBuildRequest request)
+        {
+            if (request == null)
+            {
+                return Fail("Build request is null.");
+            }
+
+            if (string.IsNullOrWhiteSpace(request.OutputPath))
+            {
+                return Fail("Build output path is missing.");
+            }
+
+            if (EditorApplication.isCompiling)
+            {
+                return Fail("Unity is compiling. Please wait for compilation to finish before building.");
+            }
+
+            if (!ValidateConfigurationAssets(request.Profile))
+            {
+                return Fail("Configuration assets are not valid. Please configure the Hyper SDK assets correctly.");
+            }
+
+            HyperBuildAssistant.ClearBuildInfo();
+            HyperBuildAssistant.ResetOptimizationSummary();
+
+            BuildSettingsSnapshot settingsSnapshot = CaptureBuildSettingsSnapshot();
+
+            try
+            {
+                PrepareBuildOutputDirectory(request.OutputPath, request.CleanOutputFolder);
+
+                ForceAssetRepack();
+
+                ApplyProfileSettings(request.Profile);
+
+                BuildPlayerOptions buildOptions = new BuildPlayerOptions
+                {
+                    scenes = GetEnabledScenes(),
+                    locationPathName = request.OutputPath,
+                    target = BuildTarget.WebGL,
+                    options = BuildOptions.DetailedBuildReport
+                };
+
+                string profileLabel = request.Profile == HyperBuildProfile.Development
+                    ? "Development"
+                    : "Release";
+
+                HyperDebug.Action($"Starting {profileLabel} Build to: {request.OutputPath}");
+
+                BuildReport report = BuildPipeline.BuildPlayer(buildOptions);
+
+                bool succeeded = report.summary.result == BuildResult.Succeeded;
+
+                if (succeeded)
+                {
+                    HyperDebug.LogSuccess($"{profileLabel} build completed successfully");
+
+                    HyperBuildAssistant.UpdateBuildInfo(request.OutputPath, report);
+
+                    if (request.OpenOutputFolder)
+                    {
+                        HyperBuildAssistant.OpenBuildOutputFolder(request.OutputPath);
+                    }
+
+                    return new HyperBuildResult
+                    {
+                        Succeeded = true,
+                        BuildResult = report.summary.result,
+                        OutputPath = request.OutputPath,
+                        TotalSizeBytes = (long)report.summary.totalSize,
+                        Message = $"{profileLabel} build completed successfully."
+                    };
+                }
+
+                HyperDebug.LogError($"{profileLabel} build failed: {report.summary.result}");
+
+                HyperBuildAssistant.UpdateBuildInfo(request.OutputPath, null);
+
+                return new HyperBuildResult
+                {
+                    Succeeded = false,
+                    BuildResult = report.summary.result,
+                    OutputPath = request.OutputPath,
+                    TotalSizeBytes = (long)report.summary.totalSize,
+                    Message = $"{profileLabel} build failed: {report.summary.result}"
+                };
+            }
+            catch (Exception ex)
+            {
+                HyperDebug.LogError($"Hyper build failed: {ex.Message}\n{ex.StackTrace}");
+
+                HyperBuildAssistant.UpdateBuildInfo(request.OutputPath, null);
+
+                return new HyperBuildResult
+                {
+                    Succeeded = false,
+                    BuildResult = BuildResult.Failed,
+                    OutputPath = request.OutputPath,
+                    Message = ex.Message
+                };
+            }
+            finally
+            {
+                RestoreBuildSettingsSnapshot(settingsSnapshot);
+            }
+        }
+
+        private static HyperBuildResult Fail(string message)
+        {
+            HyperDebug.LogError(message);
+
+            return new HyperBuildResult
+            {
+                Succeeded = false,
+                BuildResult = BuildResult.Failed,
+                Message = message
+            };
+        }
+
+        private static void PrepareBuildOutputDirectory(string outputPath, bool cleanOutputFolder)
+        {
+            if (!cleanOutputFolder)
+            {
+                return;
+            }
+
+            if (!Directory.Exists(outputPath))
+            {
+                return;
+            }
+
+            try
+            {
+                Directory.Delete(outputPath, true);
+
+                if (HyperBuildAssistant.IsSDKDeveloper())
+                {
+                    HyperDebug.Log($"Cleaned existing build folder: {outputPath}");
+                }
+            }
+            catch (Exception ex)
+            {
+                HyperDebug.LogWarning($"Could not clean build folder: {ex.Message}");
+            }
+        }
+
+        private static void ApplyProfileSettings(HyperBuildProfile profile)
+        {
+            switch (profile)
+            {
+                case HyperBuildProfile.Development:
+                    SetBuildDefineSymbols(isRelease: false);
+                    ApplyDevelopmentBuildSettings();
+                    break;
+
+                case HyperBuildProfile.Release:
+                    SetBuildDefineSymbols(isRelease: true);
+                    HyperBuildAssistant.AddOptimizationSummary("Runtime: Unity debug logger disabled in player (HYPER_RELEASE_BUILD)");
+                    ApplyReleaseBuildSettings();
+                    break;
+
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(profile), profile, "Unknown Hyper build profile.");
+            }
+        }
+
+        private static BuildSettingsSnapshot CaptureBuildSettingsSnapshot()
+        {
+            var snapshot = new BuildSettingsSnapshot();
+
+            try
+            {
+                Type webglType = typeof(PlayerSettings.WebGL);
+
+                var codeOptProp = webglType.GetProperty("codeOptimization");
+                if (codeOptProp != null)
+                {
+                    snapshot.CodeOptimizationValue = codeOptProp.GetValue(null);
+                    snapshot.HasCodeOptimization = true;
+                }
+
+                var debugSymbolProp = webglType.GetProperty("debugSymbolMode");
+                if (debugSymbolProp != null)
+                {
+                    snapshot.DebugSymbolModeValue = debugSymbolProp.GetValue(null);
+                    snapshot.HasDebugSymbolMode = true;
+                }
+            }
+            catch (Exception ex)
+            {
+                HyperDebug.LogWarning($"Could not capture code optimization/debug symbols: {ex.Message}");
+            }
+
+            try
+            {
+                snapshot.ExceptionSupportValue = PlayerSettings.WebGL.exceptionSupport;
+                snapshot.HasExceptionSupport = true;
+            }
+            catch (Exception ex)
+            {
+                HyperDebug.LogWarning($"Could not capture exception support: {ex.Message}");
+            }
+
+            try
+            {
+                snapshot.Il2CppCodeGenerationValue = PlayerSettings.GetIl2CppCodeGeneration(NamedBuildTarget.WebGL);
+                snapshot.HasIl2CppCodeGeneration = true;
+            }
+            catch (Exception ex)
+            {
+                HyperDebug.LogWarning($"Could not capture IL2CPP code generation: {ex.Message}");
+            }
+
+            return snapshot;
+        }
+
+        private static void RestoreBuildSettingsSnapshot(BuildSettingsSnapshot snapshot)
+        {
+            try
+            {
+                Type webglType = typeof(PlayerSettings.WebGL);
+
+                if (snapshot.HasCodeOptimization)
+                {
+                    var codeOptProp = webglType.GetProperty("codeOptimization");
+                    codeOptProp?.SetValue(null, snapshot.CodeOptimizationValue);
+                }
+
+                if (snapshot.HasDebugSymbolMode)
+                {
+                    var debugSymbolProp = webglType.GetProperty("debugSymbolMode");
+                    debugSymbolProp?.SetValue(null, snapshot.DebugSymbolModeValue);
+                }
+            }
+            catch (Exception ex)
+            {
+                HyperDebug.LogWarning($"Could not restore code optimization/debug symbols: {ex.Message}");
+            }
+
+            try
+            {
+                if (snapshot.HasExceptionSupport)
+                {
+                    PlayerSettings.WebGL.exceptionSupport = snapshot.ExceptionSupportValue;
+                }
+            }
+            catch (Exception ex)
+            {
+                HyperDebug.LogWarning($"Could not restore exception support: {ex.Message}");
+            }
+
+            try
+            {
+                if (snapshot.HasIl2CppCodeGeneration)
+                {
+                    PlayerSettings.SetIl2CppCodeGeneration(NamedBuildTarget.WebGL, snapshot.Il2CppCodeGenerationValue);
+                }
+            }
+            catch (Exception ex)
+            {
+                HyperDebug.LogWarning($"Could not restore IL2CPP code generation: {ex.Message}");
+            }
+
+            AssetDatabase.Refresh();
+        }
+
+        private static void ApplyDevelopmentBuildSettings()
+        {
+            try
+            {
+                Type webglType = typeof(PlayerSettings.WebGL);
+                var codeOptProp = webglType.GetProperty("codeOptimization");
+
+                if (codeOptProp != null)
+                {
+                    Type enumType = codeOptProp.PropertyType;
+                    object shorterBuildValue = Enum.Parse(enumType, "ShorterBuildTime");
+                    codeOptProp.SetValue(null, shorterBuildValue);
+
+                    HyperBuildAssistant.AddOptimizationSummary("Code Optimization → Shorter Build Time");
+
+                    if (HyperBuildAssistant.IsSDKDeveloper())
+                    {
+                        HyperDebug.LogSuccess("Development build: Code Optimization → Shorter Build Time");
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                HyperDebug.LogWarning($"Could not set Code Optimization: {ex.Message}");
+            }
+
+            try
+            {
+                Type webglType = typeof(PlayerSettings.WebGL);
+                var debugSymbolModeProp = webglType.GetProperty("debugSymbolMode");
+
+                if (debugSymbolModeProp != null)
+                {
+                    object embeddedValue = Enum.ToObject(debugSymbolModeProp.PropertyType, 2);
+                    debugSymbolModeProp.SetValue(null, embeddedValue);
+
+                    HyperBuildAssistant.AddOptimizationSummary("Debug Symbols → Embedded");
+
+                    if (HyperBuildAssistant.IsSDKDeveloper())
+                    {
+                        HyperDebug.LogSuccess("Development build: Debug Symbols → Embedded");
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                HyperDebug.LogWarning($"Could not set Debug Symbols: {ex.Message}");
+            }
+
+            try
+            {
+                PlayerSettings.WebGL.exceptionSupport = WebGLExceptionSupport.FullWithoutStacktrace;
+                HyperBuildAssistant.AddOptimizationSummary("Exception Support → Full Without Stacktrace");
+
+                if (HyperBuildAssistant.IsSDKDeveloper())
+                {
+                    HyperDebug.LogSuccess("Development build: Exception Support → Full Without Stacktrace");
+                }
+            }
+            catch (Exception ex)
+            {
+                HyperDebug.LogWarning($"Could not set Exception Support: {ex.Message}");
+            }
+
+            HyperBuildAssistant.AddOptimizationSummary("Unity Development Build flag NOT used (keeps Brotli compression)");
+            HyperBuildAssistant.AddOptimizationSummary("Using Hyper dev API URL");
+
+            if (HyperBuildAssistant.IsSDKDeveloper())
+            {
+                HyperDebug.Log("Development build settings applied: Fast iteration with Brotli compression");
+            }
+        }
+
+        private static void ApplyReleaseBuildSettings()
+        {
+            string currentCodeOpt = "";
+
+            try
+            {
+                Type webglType = typeof(PlayerSettings.WebGL);
+                var codeOptProp = webglType.GetProperty("codeOptimization");
+
+                if (codeOptProp != null)
+                {
+                    object value = codeOptProp.GetValue(null);
+                    if (value != null)
+                    {
+                        currentCodeOpt = value.ToString();
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                HyperDebug.LogWarning($"Could not read current Code Optimization setting: {ex.Message}");
+            }
+
+            bool isShorterBuildTime = !string.IsNullOrEmpty(currentCodeOpt) &&
+                                      currentCodeOpt.Contains("ShorterBuildTime");
+
+            if (isShorterBuildTime)
+            {
+                if (HyperBuildAssistant.IsSDKDeveloper())
+                {
+                    HyperDebug.Log("Release build: Respecting developer's 'Shorter Build Time' choice - no Code Optimization changes applied.");
+                }
+
+                return;
+            }
+
+            bool isRuntimePreference = !string.IsNullOrEmpty(currentCodeOpt) &&
+                                       (currentCodeOpt.Contains("Runtime") || currentCodeOpt.Contains("Faster"));
+
+            bool isDiskPreference = !string.IsNullOrEmpty(currentCodeOpt) &&
+                                    (currentCodeOpt.Contains("DiskSize") || currentCodeOpt.Contains("Disk"));
+
+            bool wantsDiskSize = isDiskPreference ||
+                                 string.IsNullOrEmpty(currentCodeOpt) ||
+                                 (!isRuntimePreference && !isDiskPreference);
+
+            try
+            {
+                Type webglType = typeof(PlayerSettings.WebGL);
+                var codeOptProp = webglType.GetProperty("codeOptimization");
+
+                if (codeOptProp != null)
+                {
+                    Type enumType = codeOptProp.PropertyType;
+                    string[] enumNames = Enum.GetNames(enumType);
+
+                    string targetValue = wantsDiskSize
+                        ? Array.IndexOf(enumNames, "DiskSizeLTO") >= 0 ? "DiskSizeLTO" : "DiskSize"
+                        : Array.IndexOf(enumNames, "FasterRuntimeLTO") >= 0 ? "FasterRuntimeLTO" : "FasterRuntime";
+
+                    object enumValue = Enum.Parse(enumType, targetValue);
+                    codeOptProp.SetValue(null, enumValue);
+
+                    HyperBuildAssistant.AddOptimizationSummary($"Code Optimization → {targetValue}");
+
+                    if (HyperBuildAssistant.IsSDKDeveloper())
+                    {
+                        HyperDebug.LogSuccess($"Release build: Code Optimization → {targetValue}");
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                HyperDebug.LogWarning($"Could not set Code Optimization: {ex.Message}");
+            }
+
+            try
+            {
+                if (wantsDiskSize)
+                {
+                    PlayerSettings.SetIl2CppCodeGeneration(NamedBuildTarget.WebGL, Il2CppCodeGeneration.OptimizeSize);
+                    HyperBuildAssistant.AddOptimizationSummary("IL2CPP Code Generation → Optimize Size");
+
+                    if (HyperBuildAssistant.IsSDKDeveloper())
+                    {
+                        HyperDebug.LogSuccess("Release build: IL2CPP Code Generation → Optimize Size");
+                    }
+                }
+                else
+                {
+                    PlayerSettings.SetIl2CppCodeGeneration(NamedBuildTarget.WebGL, Il2CppCodeGeneration.OptimizeSpeed);
+                    HyperBuildAssistant.AddOptimizationSummary("IL2CPP Code Generation → Optimize Speed");
+
+                    if (HyperBuildAssistant.IsSDKDeveloper())
+                    {
+                        HyperDebug.LogSuccess("Release build: IL2CPP Code Generation → Optimize Speed");
+                    }
+                }
+            }
+            catch (Exception)
+            {
+                HyperDebug.LogWarning("IL2CPP code generation setting not available in this Unity version");
+            }
+        }
+
+        private static void SetBuildDefineSymbols(bool isRelease)
+        {
+            try
+            {
+                string defines = PlayerSettings.GetScriptingDefineSymbols(NamedBuildTarget.WebGL);
+
+                bool hasReleaseDefine = HasDefine(defines, ReleaseDefine);
+                bool hasDevelopmentDefine = HasDefine(defines, DevelopmentDefine);
+
+                if (isRelease)
+                {
+                    if (!hasReleaseDefine)
+                    {
+                        defines = AddDefine(defines, ReleaseDefine);
+                        HyperDebug.LogSuccess("Set HYPER_RELEASE_BUILD (production API URL; Unity debug logger off in player)");
+                    }
+
+                    if (hasDevelopmentDefine)
+                    {
+                        defines = RemoveDefine(defines, DevelopmentDefine);
+                        HyperDebug.LogSuccess("Removed HYPER_DEVELOPMENT_BUILD define symbol for release build");
+                    }
+                }
+                else
+                {
+                    if (hasReleaseDefine)
+                    {
+                        defines = RemoveDefine(defines, ReleaseDefine);
+                        HyperDebug.LogSuccess("Removed HYPER_RELEASE_BUILD define symbol for dev API URL");
+                    }
+
+                    if (!hasDevelopmentDefine)
+                    {
+                        defines = AddDefine(defines, DevelopmentDefine);
+                        HyperDebug.LogSuccess("Set HYPER_DEVELOPMENT_BUILD define symbol for development build");
+                    }
+                }
+
+                PlayerSettings.SetScriptingDefineSymbols(NamedBuildTarget.WebGL, defines);
+            }
+            catch (Exception ex)
+            {
+                HyperDebug.LogWarning($"Could not set Hyper build define symbols: {ex.Message}");
+            }
+        }
+
+        private static bool HasDefine(string defines, string targetDefine)
+        {
+            if (string.IsNullOrWhiteSpace(defines))
+                return false;
+
+            string[] splitDefines = defines.Split(';');
+
+            foreach (string define in splitDefines)
+            {
+                if (define.Trim() == targetDefine)
+                    return true;
+            }
+
+            return false;
+        }
+
+        private static string AddDefine(string defines, string targetDefine)
+        {
+            if (string.IsNullOrWhiteSpace(defines))
+                return targetDefine;
+
+            if (HasDefine(defines, targetDefine))
+                return defines;
+
+            return $"{defines};{targetDefine}";
+        }
+
+        private static string RemoveDefine(string defines, string targetDefine)
+        {
+            if (string.IsNullOrWhiteSpace(defines))
+                return "";
+
+            string[] splitDefines = defines.Split(';');
+            string cleaned = "";
+
+            foreach (string define in splitDefines)
+            {
+                string trimmed = define.Trim();
+
+                if (string.IsNullOrWhiteSpace(trimmed))
+                    continue;
+
+                if (trimmed == targetDefine)
+                    continue;
+
+                cleaned = string.IsNullOrEmpty(cleaned)
+                    ? trimmed
+                    : $"{cleaned};{trimmed}";
+            }
+
+            return cleaned;
+        }
+
+        private static string[] GetEnabledScenes()
+        {
+            var scenes = new System.Collections.Generic.List<string>();
+
+            foreach (EditorBuildSettingsScene scene in EditorBuildSettings.scenes)
+            {
+                if (scene.enabled)
+                {
+                    scenes.Add(scene.path);
+                }
+            }
+
+            return scenes.ToArray();
+        }
+
+        private static void ForceAssetRepack()
+        {
+            const string hyperLoaderScenePath = HyperConstants.HYPER_LOADER_SCENE_PATH;
+            const string markerPrefix = "__HyperSDK_BuildMarker";
+
+            if (HyperBuildAssistant.IsSDKDeveloper())
+            {
+                HyperDebug.Log("ForceAssetRepack() called");
+            }
+
+            try
+            {
+                Scene hyperLoaderScene = EditorSceneManager.GetSceneByPath(hyperLoaderScenePath);
+                bool sceneWasLoaded = hyperLoaderScene.IsValid() && hyperLoaderScene.isLoaded;
+
+                if (!sceneWasLoaded)
+                {
+                    hyperLoaderScene = EditorSceneManager.OpenScene(hyperLoaderScenePath, OpenSceneMode.Additive);
+                }
+
+                GameObject markerObject = FindMarkerObject(hyperLoaderScene, markerPrefix);
+
+                if (markerObject == null)
+                {
+                    markerObject = new GameObject(markerPrefix);
+
+                    if (hyperLoaderScene.rootCount > 0)
+                    {
+                        markerObject.transform.SetParent(hyperLoaderScene.GetRootGameObjects()[0].transform, false);
+                    }
+
+                    EditorSceneManager.MoveGameObjectToScene(markerObject, hyperLoaderScene);
+                }
+
+                string newName = $"{markerPrefix}_{DateTime.Now.Ticks}";
+                markerObject.name = newName;
+
+                EditorSceneManager.MarkSceneDirty(hyperLoaderScene);
+                EditorSceneManager.SaveScene(hyperLoaderScene);
+
+                if (HyperBuildAssistant.IsSDKDeveloper())
+                {
+                    HyperDebug.Log($"Renamed build marker to '{newName}'");
+                }
+
+                if (!sceneWasLoaded)
+                {
+                    EditorSceneManager.CloseScene(hyperLoaderScene, true);
+                }
+            }
+            catch (Exception ex)
+            {
+                HyperDebug.LogWarning($"Could not force asset repack: {ex.Message}");
+            }
+        }
+
+        private static GameObject FindMarkerObject(Scene scene, string markerPrefix)
+        {
+            foreach (GameObject root in scene.GetRootGameObjects())
+            {
+                Transform marker = FindMarkerRecursive(root.transform, markerPrefix);
+
+                if (marker != null)
+                {
+                    return marker.gameObject;
+                }
+            }
+
+            return null;
+        }
+
+        private static Transform FindMarkerRecursive(Transform parent, string markerPrefix)
+        {
+            if (parent.name.StartsWith(markerPrefix, StringComparison.Ordinal))
+            {
+                return parent;
+            }
+
+            foreach (Transform child in parent)
+            {
+                Transform result = FindMarkerRecursive(child, markerPrefix);
+
+                if (result != null)
+                    return result;
+            }
+
+            return null;
+        }
+
+        private static bool LoadConfigurationAssets()
+        {
+            _gameContentConfig = AssetDatabase.LoadAssetAtPath<HyperGameContentConfig>(
+                HyperConstants.GAME_CONTENT_ASSET_PATH);
+
+            if (_gameContentConfig == null)
+            {
+                HyperDebug.LogError($"HyperGameContentConfig not found at: {HyperConstants.GAME_CONTENT_ASSET_PATH}");
+                return false;
+            }
+
+            _sdkSettings = AssetDatabase.LoadAssetAtPath<HyperSDKSettings>(
+                HyperConstants.SETTINGS_ASSET_PATH);
+
+            if (_sdkSettings == null)
+            {
+                HyperDebug.LogError($"HyperSDKSettings not found at: {HyperConstants.SETTINGS_ASSET_PATH}");
+                return false;
+            }
+
+            return true;
+        }
+
+        private static bool ValidateConfigurationAssets(HyperBuildProfile profile)
+        {
+            if (!LoadConfigurationAssets())
+            {
+                return false;
+            }
+
+            if (profile == HyperBuildProfile.Development)
+            {
+                if (!_gameContentConfig.HasScenesContent)
+                {
+                    HyperDebug.LogError("HyperGameContentConfig is missing scenes content. Development builds require scenes content.");
+                    return false;
+                }
+            }
+            else if (profile == HyperBuildProfile.Release)
+            {
+                if (!_gameContentConfig.HasScenesContent)
+                {
+                    HyperDebug.LogError("HyperGameContentConfig is missing scenes content. Release builds require scenes content.");
+                    return false;
+                }
+
+                if (!_gameContentConfig.HasPosterContent)
+                {
+                    HyperDebug.LogError("HyperGameContentConfig is missing poster content. Release builds require poster content.");
+                    return false;
+                }
+            }
+
+            if (!_sdkSettings.IsConfigured)
+            {
+                HyperDebug.LogError("HyperSDKSettings is not configured. Please configure at least one platform/orientation flag.");
+                return false;
+            }
+
+            return true;
+        }
+    }
+
+    public static class HyperBuildCLI
+    {
+        public static void BuildFromCommandLine()
+        {
+            string[] args = Environment.GetCommandLineArgs();
+
+            string profileValue = GetArg(args, "-hyperBuildProfile", "release");
+            string outputPath = GetArg(args, "-hyperBuildOutputPath", "");
+
+            if (string.IsNullOrWhiteSpace(outputPath))
+            {
+                HyperDebug.LogError("Missing required argument: -hyperBuildOutputPath <path>");
+                EditorApplication.Exit(1);
+                return;
+            }
+
+            HyperBuildProfile profile;
+
+            if (profileValue.Equals("development", StringComparison.OrdinalIgnoreCase) ||
+                profileValue.Equals("dev", StringComparison.OrdinalIgnoreCase))
+            {
+                profile = HyperBuildProfile.Development;
+            }
+            else if (profileValue.Equals("release", StringComparison.OrdinalIgnoreCase) ||
+                     profileValue.Equals("prod", StringComparison.OrdinalIgnoreCase))
+            {
+                profile = HyperBuildProfile.Release;
+            }
+            else
+            {
+                HyperDebug.LogError($"Invalid -hyperBuildProfile value: {profileValue}. Expected development or release.");
+                EditorApplication.Exit(1);
+                return;
+            }
+
+            HyperBuildResult result = HyperBuildPipeline.Build(new HyperBuildRequest
+            {
+                Profile = profile,
+                OutputPath = outputPath,
+                CleanOutputFolder = true,
+                OpenOutputFolder = false,
+                IsCliBuild = true
+            });
+
+            if (result.Succeeded)
+            {
+                HyperDebug.Log($"Hyper build succeeded: {result.OutputPath}");
+                EditorApplication.Exit(0);
+            }
+            else
+            {
+                HyperDebug.LogError($"Hyper build failed: {result.Message}");
+                EditorApplication.Exit(1);
+            }
+        }
+
+        private static string GetArg(string[] args, string argName, string fallback)
+        {
+            for (int i = 0; i < args.Length - 1; i++)
+            {
+                if (args[i] == argName)
+                {
+                    return args[i + 1];
+                }
+            }
+
+            return fallback;
+        }
+    }
+}
+#endif