ai.muna.muna 0.0.42

package/Editor/Build/AndroidBuildHandler.cs

@@ -0,0 +1,96 @@
+/* 
+*   Muna
+*   Copyright © 2025 NatML Inc. All rights reserved.
+*/
+
+namespace Muna.Editor.Build {
+
+    using System;
+    using System.Collections.Generic;
+    using System.IO;
+    using System.Linq;
+    using System.Threading.Tasks;
+    using UnityEngine;
+    using UnityEditor;
+    using UnityEditor.Android;
+    using UnityEditor.Build.Reporting;
+    using API;
+    using Services;
+    using MunaSettings = Internal.MunaSettings;
+
+    internal sealed class AndroidBuildHandler : BuildHandler, IPostGenerateGradleAndroidProject {
+
+        private static List<CachedPrediction> cache;
+        private static Dictionary<AndroidArchitecture, string> ArchToClientId = new() {
+            [AndroidArchitecture.ARMv7]     = @"android-armeabi-v7a",
+            [AndroidArchitecture.ARM64]     = @"android-arm64-v8a",
+        };
+
+        protected override BuildTarget[] targets => new[] {
+            BuildTarget.Android
+        };
+
+        protected override MunaSettings CreateSettings(BuildReport report) {
+            var projectSettings = MunaProjectSettings.instance;
+            var settings = MunaSettings.Create(projectSettings.accessKey);
+            var embeds = GetEmbeds();
+            var targets = ArchToClientId
+                .Where(pair => PlayerSettings.Android.targetArchitectures.HasFlag(pair.Key))
+                .Select(pair => pair.Value)
+                .ToArray();
+            var cache = embeds
+                .SelectMany(embed => {
+                    var client = new DotNetClient(embed.url, embed.accessKey);
+                    var muna = new Muna(client);
+                    var predictions = targets.SelectMany(target => embed.tags.Select(tag => {
+                        try {
+                            var prediction = Task.Run(() => muna.Predictions.Create(
+                                tag,
+                                clientId: target,
+                                configurationId: @""
+                            )).Result;
+                            return new CachedPrediction(prediction, target);
+                        } catch (AggregateException ex) {
+                            Debug.LogWarning($"Muna: Failed to embed {tag} predictor with error: {ex.InnerException}. Predictions with this predictor will likely fail at runtime.");
+                            return null;
+                        }
+                    }));
+                    return predictions;
+                })
+                .Where(pred => pred != null)
+                .ToList();
+            settings.cache = cache;
+            AndroidBuildHandler.cache = cache;
+            return settings;
+        }
+
+        void IPostGenerateGradleAndroidProject.OnPostGenerateGradleAndroidProject(string projectPath) {
+            if (cache == null)
+                return;
+            foreach (var prediction in cache) {
+                // Check
+                var arch = prediction.clientId.Replace("android-", string.Empty).Replace(":", string.Empty);
+                var libDir = Path.Combine(projectPath, @"src", @"main", @"jniLibs", arch);
+                if (!Directory.Exists(libDir))
+                    continue;
+                // Fetch resources
+                var client = new DotNetClient(Muna.URL);
+                foreach (var resource in prediction.resources) {
+                    try {
+                        if (resource.type != @"dso")
+                            continue;
+                        var baseName = Path.GetFileName(PredictionService.GetResourcePath(resource, libDir));
+                        var libName = $"lib{baseName}.so";
+                        var path = Path.Combine(libDir, libName);
+                        using var dsoStream = Task.Run(() => client.Download(resource.url)).Result;
+                        using var fileStream = File.Create(path);
+                        dsoStream.CopyTo(fileStream);
+                    } catch (AggregateException ex) {
+                        Debug.LogWarning($"Muna: Failed to embed prediction resource for {prediction.tag} predictor with error: {ex.InnerException}. Predictions with this predictor will likely fail at runtime.");
+                    }
+                }
+            }
+            cache = null;
+        }
+    }
+}

package/Editor/Build/AndroidBuildHandler.cs.meta

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

package/Editor/Build/BuildHandler.cs

@@ -0,0 +1,128 @@
+/* 
+*   Muna
+*   Copyright © 2025 NatML Inc. All rights reserved.
+*/
+
+#nullable enable
+
+using MunaClient = Muna.Muna;
+using EmbedAttribute = Muna.Muna.EmbedAttribute;
+
+namespace Muna.Editor.Build {
+
+    using System;
+    using System.Collections.Generic;
+    using System.IO;
+    using System.Linq;
+    using System.Reflection;
+    using UnityEditor;
+    using UnityEditor.Build;
+    using UnityEditor.Build.Reporting;
+    using UnityEngine;
+    using Internal;
+
+    internal abstract class BuildHandler : IPreprocessBuildWithReport {
+    
+        #region --Client API--
+        internal struct Embed {
+            public string url;
+            public string? accessKey;
+            public string[] tags;
+        }
+
+        protected abstract BuildTarget[] targets { get; }
+        public virtual int callbackOrder => -1_000_000; // run very early, but not too early ;)
+
+        protected abstract MunaSettings CreateSettings(BuildReport report);
+
+        internal static Embed[] GetEmbeds() {
+            var assemblies = AppDomain.CurrentDomain.GetAssemblies();
+            var types = assemblies.SelectMany(assembly => assembly.GetTypes()).ToArray();
+            var defaultEmbeds = types
+                .SelectMany(type => Attribute.GetCustomAttributes(type, typeof(EmbedAttribute)))
+                .Cast<EmbedAttribute>()
+                .Select(embed => new Embed {
+                    url = MunaClient.URL,
+                    accessKey = MunaProjectSettings.instance.accessKey,
+                    tags = embed.tags
+                })
+                .ToArray();
+            var customEmbeds = types
+                .SelectMany(type => { // thanks Jamie!
+                    try {
+                        return type.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);
+                    }
+                    catch (Exception ex) {
+                        Debug.LogWarning($"Muna: Failed to inspect type {type} for predictor embeds with exception: {ex.Message}. Predictions might fail at runtime.");
+                        return new PropertyInfo[0];
+                    }
+                })
+                .Where(property =>
+                    Attribute.IsDefined(property, typeof(EmbedAttribute)) &&
+                    property.PropertyType == typeof(MunaClient)
+                )
+                .Select(property  => {
+                    var attribute = property.GetCustomAttribute<EmbedAttribute>();
+                    var getter = CreateDelegateForProperty<MunaClient>(property);
+                    var muna = getter!();
+                    return new Embed {
+                        url = muna.client.url,
+                        accessKey = muna.client.accessKey,
+                        tags = attribute.tags
+                    };
+                })
+                .ToArray();
+            return Enumerable.Concat(defaultEmbeds, customEmbeds).ToArray();
+        }
+        #endregion
+
+
+        #region --Operations--
+        protected const string CachePath = @"Assets/__MUNA_DELETE_THIS__";
+
+        void IPreprocessBuildWithReport.OnPreprocessBuild(BuildReport report) {
+            if (!targets.Contains(report.summary.platform))
+                return;
+            var settings = CreateSettings(report);
+            EditorApplication.update += FailureListener;
+            ClearSettings();
+            EmbedSettings(settings);
+        }
+
+        private void FailureListener() {
+            if (BuildPipeline.isBuildingPlayer)
+                return;
+            ClearSettings();
+            EditorApplication.update -= FailureListener;
+        }
+        #endregion
+
+
+        #region --Utilities--
+
+        private static void EmbedSettings(MunaSettings settings) {
+            Directory.CreateDirectory(CachePath);
+            AssetDatabase.CreateAsset(settings, $"{CachePath}/Muna.asset");
+            var assets = PlayerSettings.GetPreloadedAssets()?.ToList() ?? new List<UnityEngine.Object>();
+            assets.Add(settings);
+            PlayerSettings.SetPreloadedAssets(assets.ToArray());
+        }
+
+        private static void ClearSettings() {
+            var assets = PlayerSettings.GetPreloadedAssets()?.ToList();
+            if (assets != null) {
+                assets.RemoveAll(asset => asset && asset.GetType() == typeof(MunaSettings));
+                PlayerSettings.SetPreloadedAssets(assets.ToArray());
+            }
+            AssetDatabase.DeleteAsset(CachePath);
+        }
+
+        private static Func<T>? CreateDelegateForProperty<T>(PropertyInfo property) {
+            var getter = property.GetGetMethod(true);
+            return getter != null && getter.ReturnType == typeof(T) ?
+                (Func<T>)Delegate.CreateDelegate(typeof(Func<T>), getter) :
+                null;
+        }
+        #endregion
+    }
+}

package/Editor/Build/BuildHandler.cs.meta

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

package/Editor/Build/LinuxBuildHandler.cs

@@ -0,0 +1,26 @@
+/* 
+*   Muna
+*   Copyright © 2025 NatML Inc. All rights reserved.
+*/
+
+namespace Muna.Editor.Build {
+
+    using UnityEditor;
+    using UnityEditor.Build.Reporting;
+    using MunaSettings = Internal.MunaSettings;
+
+    internal sealed class LinuxBuildHandler : BuildHandler {
+
+        protected override BuildTarget[] targets => new [] {
+            BuildTarget.StandaloneLinux64,
+            BuildTarget.LinuxHeadlessSimulation,
+            BuildTarget.EmbeddedLinux,
+        };
+
+        protected override MunaSettings CreateSettings(BuildReport report) {
+            var projectSettings = MunaProjectSettings.instance;
+            var settings = MunaSettings.Create(projectSettings.accessKey);
+            return settings;
+        }
+    }
+}

package/Editor/Build/LinuxBuildHandler.cs.meta

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

package/Editor/Build/WebGLBuildHandler.cs

@@ -0,0 +1,69 @@
+/* 
+*   Muna
+*   Copyright © 2025 NatML Inc. All rights reserved.
+*/
+
+#nullable enable
+
+namespace Muna.Editor.Build {
+
+    using System.Collections.Generic;
+    using System.IO;
+    using System.Text.RegularExpressions;
+    using UnityEditor;
+    using UnityEditor.Build.Reporting;
+    using MunaSettings = Internal.MunaSettings;
+
+    internal sealed class WebGLBuildHandler : BuildHandler {
+
+        protected override BuildTarget[] targets => new[] {
+            BuildTarget.WebGL
+        };
+        private static string[] EM_ARGS => new [] {
+            @"-Wl,-uFXN_WEBGL_INIT",
+            @"-lembind",
+            @"-sEXTRA_EXPORTED_RUNTIME_METHODS=FS",
+        };
+
+        protected override MunaSettings CreateSettings(BuildReport report) {
+            var configPath = Path.Combine(GetEmscriptenPath(), @"tools", @"config.py");
+            if (File.Exists(configPath)) {
+                var config = File.ReadAllText(configPath).TrimEnd();
+                if (!Regex.IsMatch(config, @"FROZEN_CACHE\s*=\s*False\s*$", RegexOptions.Multiline))
+                    File.WriteAllText(configPath, config + "\nFROZEN_CACHE = False");
+            }
+            PlayerSettings.WebGL.emscriptenArgs = GetEmscriptenArgs();
+            var projectSettings = MunaProjectSettings.instance;
+            var settings = MunaSettings.Create(projectSettings.accessKey);
+            return settings;
+        }
+
+        private static string GetEmscriptenArgs() {
+            var cleanedArgs = Regex.Replace(
+                PlayerSettings.WebGL.emscriptenArgs,
+                @"-Wl,-uFXN_WEBGL_PUSH.*?-Wl,-uFXN_WEBGL_POP",
+                string.Empty,
+                RegexOptions.Singleline
+            ).Split(' ');
+            var args = new List<string>();
+            args.AddRange(cleanedArgs);
+            args.Add(@"-Wl,-uFXN_WEBGL_PUSH");
+            args.AddRange(EM_ARGS);
+            args.Add(@"-Wl,-uFXN_WEBGL_POP");
+            return string.Join(@" ", args);
+        }
+
+        private static string GetEmscriptenPath() {
+            var rootDir = Path.GetDirectoryName(EditorApplication.applicationPath);
+            var emccDir = Path.Combine(
+                rootDir,
+                @"PlaybackEngines",
+                @"WebGLSupport",
+                @"BuildTools",
+                @"Emscripten",
+                @"emscripten"
+            );
+            return emccDir;
+        }
+    }
+}

package/Editor/Build/WebGLBuildHandler.cs.meta

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

package/Editor/Build/WindowsBuildHandler.cs

@@ -0,0 +1,24 @@
+/* 
+*   Muna
+*   Copyright © 2025 NatML Inc. All rights reserved.
+*/
+
+namespace Muna.Editor.Build {
+
+    using UnityEditor;
+    using UnityEditor.Build.Reporting;
+    using MunaSettings = Internal.MunaSettings;
+
+    internal sealed class WindowsBuildHandler : BuildHandler {
+
+        protected override BuildTarget[] targets => new[] {
+            BuildTarget.StandaloneWindows64
+        };
+
+        protected override MunaSettings CreateSettings(BuildReport report) {
+            var projectSettings = MunaProjectSettings.instance;
+            var settings = MunaSettings.Create(projectSettings.accessKey);
+            return settings;
+        }
+    }
+}

package/Editor/Build/WindowsBuildHandler.cs.meta

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

package/Editor/Build/iOSBuildHandler.cs

@@ -0,0 +1,119 @@
+/* 
+*   Muna
+*   Copyright © 2025 NatML Inc. All rights reserved.
+*/
+
+namespace Muna.Editor.Build {
+
+    using System;
+    using System.Collections.Generic;
+    using System.IO;
+    using System.IO.Compression;
+    using System.Linq;
+    using System.Threading.Tasks;
+    using UnityEngine;
+    using UnityEditor;
+    using UnityEditor.Build;
+    using UnityEditor.Build.Reporting;
+    using API;
+    using MunaSettings = Internal.MunaSettings;
+
+#if UNITY_IOS || UNITY_VISIONOS
+    using UnityEditor.iOS.Xcode;
+    using UnityEditor.iOS.Xcode.Extensions;
+#endif
+
+    internal sealed class iOSBuildHandler : BuildHandler, IPostprocessBuildWithReport {
+
+        private List<CachedPrediction> cache;
+        private static readonly Dictionary<BuildTarget, string> ClientIds = new () {
+            [BuildTarget.iOS] = @"ios-arm64",
+            [BuildTarget.VisionOS] = @"visionos-arm64"
+        };
+
+        protected override BuildTarget[] targets => ClientIds.Keys.ToArray();
+
+        protected override MunaSettings CreateSettings(BuildReport report) {
+            var projectSettings = MunaProjectSettings.instance;
+            var settings = MunaSettings.Create(projectSettings.accessKey);
+            var embeds = GetEmbeds();
+            var cache = new List<CachedPrediction>();
+            var clientId = ClientIds[report.summary.platform];
+            foreach (var embed in embeds) {
+                var client = new DotNetClient(embed.url, embed.accessKey);
+                var muna = new Muna(client);
+                var predictions = embed.tags
+                    .Select(tag => {
+                        try {
+                            var prediction = Task.Run(() => muna.Predictions.Create(
+                                tag,
+                                clientId: clientId,
+                                configurationId: @""
+                            )).Result;
+                            return new CachedPrediction(prediction, clientId);
+                        } catch (AggregateException ex) {
+                            Debug.LogWarning($"Muna: Failed to embed {tag} predictor with error: {ex.InnerException}. Predictions with this predictor will likely fail at runtime.");
+                            return null;
+                        }
+                    })
+                    .Where(pred => pred != null)
+                    .ToArray();
+                cache.AddRange(predictions);
+            }
+            settings.cache = cache;
+            this.cache = cache;
+            return settings;
+        }
+
+        void IPostprocessBuildWithReport.OnPostprocessBuild(BuildReport report) {
+            if (!targets.Contains(report.summary.platform))
+                return;
+            if (cache == null)
+                return;
+            var frameworkDir = Path.Combine(report.summary.outputPath, @"Frameworks", @"Muna");
+            Directory.CreateDirectory(frameworkDir);
+            var client = new DotNetClient(Muna.URL);
+            var frameworks = new List<string>();
+            foreach (var prediction in cache)
+                foreach (var resource in prediction.resources) {
+                    try {
+                        if (resource.type != @"dso")
+                            continue;
+                        var dsoPath = Path.GetTempFileName();
+                        {
+                            using var dsoStream = Task.Run(() => client.Download(resource.url)).Result;
+                            using var fileStream = File.Create(dsoPath);
+                            dsoStream.CopyTo(fileStream);
+                        }
+                        ZipFile.ExtractToDirectory(dsoPath, frameworkDir, true);
+                        frameworks.Add(resource.name);
+                    } catch (AggregateException ex) {
+                        Debug.LogWarning($"Muna: Failed to embed prediction resource for {prediction.tag} predictor with error: {ex.InnerException}. Predictions with this predictor will likely fail at runtime.");
+                    }
+                }
+        #if UNITY_IOS || UNITY_VISIONOS
+            var xcodeProjectName = report.summary.platform == BuildTarget.VisionOS ?
+                @"Unity-VisionOS.xcodeproj" : // Unity needs to fix `PBXProject::GetPBXProjectPath`
+                @"Unity-iPhone.xcodeproj";
+            var pbxPath = Path.Combine(
+                report.summary.outputPath,
+                xcodeProjectName,
+                @"project.pbxproj"
+            );
+            var project = new PBXProject();
+            project.ReadFromFile(pbxPath);
+            var targetGuid = project.GetUnityMainTargetGuid();
+            foreach (var framework in frameworks) {
+                var frameworkGuid = project.AddFile(
+                    @"Frameworks/Muna/" + framework,
+                    @"Frameworks/" + framework,
+                    PBXSourceTree.Source
+                );
+                project.AddFileToEmbedFrameworks(targetGuid, frameworkGuid);
+            }
+            project.WriteToFile(pbxPath);
+        #endif
+            cache = null;
+        }
+    }
+}

package/Editor/Build/iOSBuildHandler.cs.meta

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

package/Editor/Build/macOSBuildHandler.cs

@@ -0,0 +1,133 @@
+/* 
+*   Muna
+*   Copyright © 2025 NatML Inc. All rights reserved.
+*/
+
+namespace Muna.Editor.Build {
+
+    using System;
+    using System.Collections.Generic;
+    using System.IO;
+    using System.Linq;
+    using System.Threading.Tasks;
+    using UnityEngine;
+    using UnityEditor;
+    using UnityEditor.Build;
+    using UnityEditor.Build.Reporting;
+    using API;
+    using Services;
+    using MunaSettings = Internal.MunaSettings;
+
+    #if UNITY_STANDALONE_OSX
+    using UnityEditor.iOS.Xcode;
+    using UnityEditor.iOS.Xcode.Extensions;
+    #endif
+
+    internal sealed class macOSBuildHandler : BuildHandler, IPostprocessBuildWithReport {
+
+        private List<CachedPrediction> cache;
+        private static readonly string[] ClientIds = new[] {
+            "macos-arm64",
+            "macos-x86_64"
+        };
+
+        protected override BuildTarget[] targets => new[] {
+            BuildTarget.StandaloneOSX
+        };
+
+        protected override MunaSettings CreateSettings(BuildReport report) {
+            // Create settings
+            var projectSettings = MunaProjectSettings.instance;
+            var settings = MunaSettings.Create(projectSettings.accessKey);
+            // Embed predictors
+            var embeds = GetEmbeds();
+            var cache = new List<CachedPrediction>();
+            foreach (var embed in embeds) {
+                var client = new DotNetClient(embed.url, embed.accessKey);
+                var muna = new Muna(client);
+                var predictions = (from tag in embed.tags from clientId in ClientIds select (clientId, tag))
+                    .Select((pair) => {
+                        var (clientId, tag) = pair;
+                        try {
+                            var prediction = Task.Run(() => muna.Predictions.Create(
+                                tag,
+                                clientId: clientId,
+                                configurationId: @""
+                            )).Result;
+                            return new CachedPrediction(prediction, clientId);
+                        }
+                        catch (AggregateException ex) {
+                            Debug.LogWarning($"Muna: Failed to embed {tag} predictor with error: {ex.InnerException}. Predictions with this predictor will likely fail at runtime.");
+                            return null;
+                        }
+                    })
+                    .Where(pred => pred != null)
+                    .ToArray();
+                cache.AddRange(predictions);
+            }
+            // Cache
+            settings.cache = cache;
+            this.cache = cache;
+            // Return
+            return settings;
+        }
+
+        void IPostprocessBuildWithReport.OnPostprocessBuild(BuildReport report) {
+            // Check platform
+            if (!targets.Contains(report.summary.platform))
+                return;
+            // Check cache
+            if (cache == null)
+                return;
+            // Check if app or Xcode project
+            var outputPath = report.summary.outputPath;
+            var isApp = outputPath.EndsWith(@".app");
+            var frameworkDir = isApp ?
+                Path.Combine(outputPath, @"Contents", @"Frameworks") :
+                Path.Combine(outputPath, Application.productName, @"Frameworks", @"Muna");
+            Directory.CreateDirectory(frameworkDir);
+            // Embed
+            var frameworks = new List<string>();
+            var client = new DotNetClient(Muna.URL);
+            foreach (var prediction in cache)
+                foreach (var resource in prediction.resources) {
+                    try {
+                        if (resource.type != @"dso")
+                            continue;
+                        var dsoName = Path.GetFileName(PredictionService.GetResourcePath(resource, outputPath));
+                        var dsoPath = Path.Combine(frameworkDir, dsoName);
+                        using var dsoStream = Task.Run(() => client.Download(resource.url)).Result;
+                        using var fileStream = File.Create(dsoPath);
+                        dsoStream.CopyTo(fileStream);
+                        frameworks.Add(dsoName);
+                    } catch (AggregateException ex) {
+                        Debug.LogWarning($"Muna: Failed to embed prediction resource for {prediction.tag} predictor with error: {ex.InnerException}. Predictions with this predictor will likely fail at runtime.");
+                    }
+                }
+            // Check Xcode project
+            if (isApp)
+                return;
+        #if UNITY_STANDALONE_OSX
+            // Load Xcode project
+            var projectName = new DirectoryInfo(outputPath).Name + ".xcodeproj";
+            var pbxPath = Path.Combine(outputPath, projectName,  @"project.pbxproj");
+            var project = new PBXProject();
+            project.ReadFromFile(pbxPath);
+            // Add frameworks
+            var targetGuid = project.GetUnityMainTargetGuid();
+            foreach (var framework in frameworks) {
+                var frameworkGuid = project.AddFile(
+                    $"{Application.productName}/Frameworks/Muna/" + framework,
+                    "Frameworks/" + framework,
+                    PBXSourceTree.Source
+                );
+                project.AddFileToEmbedFrameworks(targetGuid, frameworkGuid);
+            }
+            // Write
+            project.WriteToFile(pbxPath);
+        #endif
+            // Empty cache
+            cache = null;
+        }
+    }
+}

package/Editor/Build/macOSBuildHandler.cs.meta

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