ai.muna.muna 0.0.42

package/Runtime/Beta/Value.cs

@@ -0,0 +1,92 @@
+/* 
+*   Muna
+*   Copyright © 2025 NatML Inc. All rights reserved.
+*/
+
+#nullable enable
+
+namespace Muna.Beta {
+
+    using System;
+    using System.IO;
+    using System.Linq;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.Serialization;
+    using System.Text;
+
+    /// <summary>
+    /// Remote prediction value.
+    /// </summary>
+    [Preserve, Serializable]
+    internal class Value {
+
+        /// <summary>
+        /// Value URL.
+        /// </summary>
+        public string? data;
+
+        /// <summary>
+        /// Value type.
+        /// </summary>
+        public Dtype type;
+
+        /// <summary>
+        /// Value shape.
+        /// This is `null` if shape information is not available or applicable.
+        /// </summary>
+        public int[]? shape;
+    }
+
+    internal static class ValueUtils {
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static object ToObject<T>(this Stream stream, int[] shape) where T : unmanaged {
+            var data = stream.ToArray<T>();
+            return shape.Length > 0 ? new Tensor<T>(data, shape) : data[0];
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static object ToObject(this Enum value) {
+            var fieldInfo = value.GetType().GetField(value.ToString());
+            var attribute = fieldInfo?
+                .GetCustomAttributes(typeof(EnumMemberAttribute), false)?
+                .FirstOrDefault() as EnumMemberAttribute;
+            return (attribute?.IsValueSetExplicitly ?? false) ? attribute.Value : Convert.ToInt32(value);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static unsafe Stream ToStream<T>(this T[] data) where T : unmanaged {
+            if (data is byte[] raw)
+                return new MemoryStream(raw);
+            var size = data.Length * sizeof(T);
+            var array = new byte[size];
+            fixed (void* src = data, dst = array)
+                Buffer.MemoryCopy(src, dst, size, size);
+            return new MemoryStream(array);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Stream ToStream(this string data) => new MemoryStream(Encoding.UTF8.GetBytes(data));
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static unsafe T[] ToArray<T>(this Stream stream) where T : unmanaged {
+            var result = new T[stream.Length / sizeof(T)];
+            fixed (T* dst = result) 
+                using (var dstStream = new UnmanagedMemoryStream(
+                    (byte*)dst,
+                    stream.Length,
+                    stream.Length,
+                    FileAccess.Write
+                ))
+                    stream.CopyTo(dstStream);
+            return result;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Stream Clone(this Stream stream) {
+            var result = new MemoryStream();
+            stream.CopyTo(result);
+            return result;
+        }
+    }
+}

package/Runtime/Beta/Value.cs.meta

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

package/Runtime/Beta.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: e93ff2e15287c4e6d9881c345b63276d
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/C/Configuration.cs

@@ -0,0 +1,139 @@
+/* 
+*   Muna
+*   Copyright © 2025 NatML Inc. All rights reserved.
+*/
+
+#nullable enable
+
+namespace Muna.C {
+
+    using System;
+    using System.Runtime.InteropServices;
+    using System.Text;
+    using System.Threading.Tasks;
+    using static Muna;
+
+    public sealed class Configuration : IDisposable {
+
+        #region --Client API--
+
+        public string tag {
+            get {
+                var sb = new StringBuilder(2048);
+                configuration.GetConfigurationTag(sb, sb.Capacity).Throw();
+                return sb.ToString();
+            }
+            set => configuration.SetConfigurationTag(value).Throw();
+        }
+
+        public string token {
+            get {
+                var sb = new StringBuilder(2048);
+                configuration.GetConfigurationToken(sb, sb.Capacity).Throw();
+                return sb.ToString();
+            }
+            set => configuration.SetConfigurationToken(value).Throw();
+        }
+
+        public Acceleration acceleration {
+            get => configuration.GetConfigurationAcceleration(out var acceleration).Throw() == Status.Ok ? acceleration : default;
+            set => configuration.SetConfigurationAcceleration(value).Throw();
+        }
+
+        public IntPtr device {
+            get => configuration.GetConfigurationDevice(out var device).Throw() == Status.Ok ? device : default;
+            set => configuration.SetConfigurationDevice(value).Throw();
+        }
+
+        public static string ConfigurationId {
+            get {
+                var sb = new StringBuilder(2048);
+                GetConfigurationUniqueID(sb, sb.Capacity).Throw();
+                return sb.ToString();
+            }
+        }
+
+        public static string ClientId {
+            get {
+                var sb = new StringBuilder(64);
+                GetConfigurationClientID(sb, sb.Capacity).Throw();
+                return sb.ToString();
+            }
+        }
+
+        public static Task InitializationTask {
+            get {
+            #if UNITY_WEBGL && !UNITY_EDITOR
+                var tcs = new TaskCompletionSource<bool>();
+                var context = GCHandle.Alloc(tcs, GCHandleType.Normal);
+                SetInitializationHandler(OnFunctionInitialized, (IntPtr)context);
+                return tcs.Task;
+                [DllImport(Muna.Assembly, EntryPoint = @"FXNSetInitializationHandler")]
+                static extern Status SetInitializationHandler (Action<IntPtr> handler, IntPtr context);
+            #else
+                return Task.CompletedTask;
+            #endif
+            }
+        }
+
+        public Configuration() {
+            CreateConfiguration(out var configuration).Throw();
+            this.configuration = configuration;
+        }
+
+        public Task AddResource(string type, string path) {
+        #if UNITY_WEBGL && !UNITY_EDITOR
+            var tcs = new TaskCompletionSource<bool>();
+            var context = GCHandle.Alloc(tcs, GCHandleType.Normal);
+            AddConfigurationResource(configuration, type, path, OnAddConfigurationResource, (IntPtr)context);
+            return tcs.Task;
+            [DllImport(Muna.Assembly, EntryPoint = @"FXNConfigurationAddResourceAsync")]
+            static extern Status AddConfigurationResource(
+                IntPtr configuration,
+                [MarshalAs(UnmanagedType.LPUTF8Str)] string type,
+                [MarshalAs(UnmanagedType.LPUTF8Str)] string path,
+                Action<IntPtr, Status> handler,
+                IntPtr context
+            );
+        #else
+            try {
+                configuration.AddConfigurationResource(type, path).Throw();
+                return Task.CompletedTask;
+            } catch (Exception ex) {
+                return Task.FromException(ex);
+            }
+        #endif
+        }
+
+        public void Dispose() => configuration.ReleaseConfiguration();
+        #endregion
+
+
+        #region --Operations--
+        private readonly IntPtr configuration;
+
+        public static implicit operator IntPtr(Configuration configuration) => configuration.configuration;
+
+        [MonoPInvokeCallback(typeof(Action<IntPtr>))]
+        private static void OnFunctionInitialized(IntPtr context) {
+            var handle = (GCHandle)context;
+            var tcs = handle.Target as TaskCompletionSource<bool>;
+            handle.Free();
+            tcs?.SetResult(true);
+        }
+
+        [MonoPInvokeCallback(typeof(Action<IntPtr, Status>))]
+        private static void OnAddConfigurationResource(IntPtr context, Status status) {
+            var handle = (GCHandle)context;
+            var tcs = handle.Target as TaskCompletionSource<bool>;
+            handle.Free();
+            try {
+                status.Throw();
+                tcs?.SetResult(true);
+            } catch (Exception ex) {
+                tcs?.SetException(ex);
+            }
+        }
+        #endregion
+    }
+}

package/Runtime/C/Configuration.cs.meta

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

package/Runtime/C/Function.cs

@@ -0,0 +1,294 @@
+/* 
+*   Muna
+*   Copyright © 2025 NatML Inc. All rights reserved.
+*/
+
+#nullable enable
+
+namespace Muna.C {
+
+    using System;
+    using System.Runtime.InteropServices;
+    using System.Text;
+
+    internal static unsafe class Muna {
+
+        public const string Assembly =
+        #if (UNITY_IOS || UNITY_VISIONOS || UNITY_WEBGL) && !UNITY_EDITOR
+        @"__Internal";
+        #else
+        @"Function";
+        #endif
+
+
+        #region --Enumerations--
+        /// <summary>
+        /// Status codes.
+        /// </summary>
+        public enum Status : int {
+            Ok                  = 0,
+            InvalidArgument     = 1,
+            InvalidOperation    = 2,
+            NotImplemented      = 3,
+        }
+        #endregion
+
+
+        #region --FXNValue--
+        [DllImport(Assembly, EntryPoint = @"FXNValueRelease")]
+        public static extern Status ReleaseValue(this IntPtr value);
+        [DllImport(Assembly, EntryPoint = @"FXNValueGetData")]
+        public static extern Status GetValueData(
+            this IntPtr value,
+            out IntPtr data
+        );
+        [DllImport(Assembly, EntryPoint = @"FXNValueGetType")]
+        public static extern Status GetValueType(
+            this IntPtr value,
+            out Dtype type
+        );
+        [DllImport(Assembly, EntryPoint = @"FXNValueGetDimensions")]
+        public static extern Status GetValueDimensions(
+            this IntPtr value,
+            out int dimensions
+        );
+        [DllImport(Assembly, EntryPoint = @"FXNValueGetShape")]
+        public static extern Status GetValueShape(
+            this IntPtr value,
+            [Out] int[] shape,
+            int shapeLen
+        );
+        [DllImport(Assembly, EntryPoint = @"FXNValueCreateArray")]
+        public static unsafe extern Status CreateArrayValue(
+            void* data,
+            [In] int[]? shape,
+            int dims,
+            Dtype dtype,
+            Value.Flags flags,
+            out IntPtr value
+        );
+        [DllImport(Assembly, EntryPoint = @"FXNValueCreateString")]
+        public static extern Status CreateStringValue(
+            [MarshalAs(UnmanagedType.LPUTF8Str)] string data,
+            out IntPtr value
+        );
+        [DllImport(Assembly, EntryPoint = @"FXNValueCreateList")]
+        public static extern Status CreateListValue(
+            [MarshalAs(UnmanagedType.LPUTF8Str)] string data,
+            out IntPtr value
+        );
+        [DllImport(Assembly, EntryPoint = @"FXNValueCreateDict")]
+        public static extern Status CreateDictValue(
+            [MarshalAs(UnmanagedType.LPUTF8Str)] string data,
+            out IntPtr value
+        );
+        [DllImport(Assembly, EntryPoint = @"FXNValueCreateImage")]
+        public static extern Status CreateImageValue(
+            byte* pixelBuffer,
+            int width,
+            int height,
+            int channels,
+            Value.Flags flags,
+            out IntPtr value
+        );
+        [DllImport(Assembly, EntryPoint = @"FXNValueCreateBinary")]
+        public static extern Status CreateBinaryValue(
+            [In] byte[] buffer,
+            int bufferLen,
+            Value.Flags flags,
+            out IntPtr value
+        );
+        [DllImport(Assembly, EntryPoint = @"FXNValueCreateNull")]
+        public static extern Status CreateNullValue(out IntPtr value);
+        #endregion
+
+
+        #region --FXNValueMap--
+        [DllImport(Assembly, EntryPoint = @"FXNValueMapCreate")]
+        public static extern Status CreateValueMap(out IntPtr map);
+        [DllImport(Assembly, EntryPoint = @"FXNValueMapRelease")]
+        public static extern Status ReleaseValueMap(this IntPtr map);
+        [DllImport(Assembly, EntryPoint = @"FXNValueMapGetSize")]
+        public static extern Status GetValueMapSize(
+            this IntPtr map,
+            out int size
+        );
+        [DllImport(Assembly, EntryPoint = @"FXNValueMapGetKey")]
+        public static extern Status GetValueMapKey(
+            this IntPtr map,
+            int index,
+            [MarshalAs(UnmanagedType.LPUTF8Str), Out] StringBuilder key,
+            int size
+        );
+        [DllImport(Assembly, EntryPoint = @"FXNValueMapGetValue")]
+        public static extern Status GetValueMapValue(
+            this IntPtr map,
+            [MarshalAs(UnmanagedType.LPUTF8Str)] string key,
+            out IntPtr value
+        );
+        [DllImport(Assembly, EntryPoint = @"FXNValueMapSetValue")]
+        public static extern Status SetValueMapValue(
+            this IntPtr map,
+            [MarshalAs(UnmanagedType.LPUTF8Str)] string key,
+            IntPtr value
+        );
+        #endregion
+
+
+        #region --FXNConfiguration--
+        [DllImport(Assembly, EntryPoint = @"FXNConfigurationGetUniqueID")]
+        public static extern Status GetConfigurationUniqueID(
+            [MarshalAs(UnmanagedType.LPUTF8Str), Out] StringBuilder identifier,
+            int size
+        );
+        [DllImport(Assembly, EntryPoint = @"FXNConfigurationGetClientID")]
+        public static extern Status GetConfigurationClientID(
+            [MarshalAs(UnmanagedType.LPUTF8Str), Out] StringBuilder identifier,
+            int size
+        );
+        [DllImport(Assembly, EntryPoint = @"FXNConfigurationCreate")]
+        public static extern Status CreateConfiguration(out IntPtr configuration);
+        [DllImport(Assembly, EntryPoint = @"FXNConfigurationRelease")]
+        public static extern Status ReleaseConfiguration(this IntPtr configuration);
+        [DllImport(Assembly, EntryPoint = @"FXNConfigurationGetTag")]
+        public static extern Status GetConfigurationTag(
+            this IntPtr configuration,
+            [MarshalAs(UnmanagedType.LPUTF8Str), Out] StringBuilder tag,
+            int size
+        );
+        [DllImport(Assembly, EntryPoint = @"FXNConfigurationSetTag")]
+        public static extern Status SetConfigurationTag(
+            this IntPtr configuration,
+            [MarshalAs(UnmanagedType.LPUTF8Str)] string? tag
+        );
+        [DllImport(Assembly, EntryPoint = @"FXNConfigurationGetToken")]
+        public static extern Status GetConfigurationToken(
+            this IntPtr configuration,
+            [MarshalAs(UnmanagedType.LPUTF8Str), Out] StringBuilder token,
+            int size
+        );
+        [DllImport(Assembly, EntryPoint = @"FXNConfigurationSetToken")]
+        public static extern Status SetConfigurationToken(
+            this IntPtr configuration,
+            [MarshalAs(UnmanagedType.LPUTF8Str)] string? token
+        );
+        [DllImport(Assembly, EntryPoint = @"FXNConfigurationGetAcceleration")]
+        public static extern Status GetConfigurationAcceleration(
+            this IntPtr configuration,
+            out Acceleration acceleration
+        );
+        [DllImport(Assembly, EntryPoint = @"FXNConfigurationSetAcceleration")]
+        public static extern Status SetConfigurationAcceleration(
+            this IntPtr configuration,
+            Acceleration acceleration
+        );
+        [DllImport(Assembly, EntryPoint = @"FXNConfigurationSetDevice")]
+        public static extern Status SetConfigurationDevice(
+            this IntPtr configuration,
+            IntPtr device
+        );
+        [DllImport(Assembly, EntryPoint = @"FXNConfigurationGetDevice")]
+        public static extern Status GetConfigurationDevice(
+            this IntPtr configuration,
+            out IntPtr device
+        );
+        [DllImport(Assembly, EntryPoint = @"FXNConfigurationAddResource")]
+        public static extern Status AddConfigurationResource(
+            this IntPtr configuration,
+            [MarshalAs(UnmanagedType.LPUTF8Str)] string type,
+            [MarshalAs(UnmanagedType.LPUTF8Str)] string path
+        );
+        #endregion
+
+
+        #region --FXNPrediction--
+        [DllImport(Assembly, EntryPoint = @"FXNPredictionRelease")]
+        public static extern Status ReleasePrediction(this IntPtr prediction);
+        [DllImport(Assembly, EntryPoint = @"FXNPredictionGetID")]
+        public static extern Status GetPredictionID(
+            this IntPtr prediction,
+            [MarshalAs(UnmanagedType.LPUTF8Str), Out] StringBuilder id,
+            int size
+        );
+        [DllImport(Assembly, EntryPoint = @"FXNPredictionGetLatency")]
+        public static extern Status GetPredictionLatency(
+            this IntPtr prediction,
+            out double latency
+        );
+        [DllImport(Assembly, EntryPoint = @"FXNPredictionGetResults")]
+        public static extern Status GetPredictionResults(
+            this IntPtr prediction,
+            out IntPtr map
+        );
+        [DllImport(Assembly, EntryPoint = @"FXNPredictionGetError")]
+        public static extern Status GetPredictionError(
+            this IntPtr prediction,
+            [MarshalAs(UnmanagedType.LPUTF8Str), Out] StringBuilder error,
+            int size
+        );
+        [DllImport(Assembly, EntryPoint = @"FXNPredictionGetLogs")]
+        public static extern Status GetPredictionLogs(
+            this IntPtr prediction,
+            [MarshalAs(UnmanagedType.LPUTF8Str), Out] StringBuilder logs,
+            int size
+        );
+        [DllImport(Assembly, EntryPoint = @"FXNPredictionGetLogLength")]
+        public static extern Status GetPredictionLogLength(
+            this IntPtr prediction,
+            out int size
+        );
+        #endregion
+
+
+        #region --FXNPredictionStream--
+        [DllImport(Assembly, EntryPoint = @"FXNPredictionStreamRelease")]
+        public static extern Status ReleasePredictionStream(this IntPtr stream);
+        [DllImport(Assembly, EntryPoint = @"FXNPredictionStreamReadNext")]
+        public static extern Status ReadNextPrediction(
+            this IntPtr stream,
+            out IntPtr prediction
+        );
+        #endregion
+
+
+        #region --FXNPredictor--
+        [DllImport(Assembly, EntryPoint = @"FXNPredictorCreate")]
+        public static extern Status CreatePredictor(
+            IntPtr configuration,
+            out IntPtr predictor
+        );
+        [DllImport(Assembly, EntryPoint = @"FXNPredictorRelease")]
+        public static extern Status ReleasePredictor(this IntPtr predictor);
+        [DllImport(Assembly, EntryPoint = @"FXNPredictorCreatePrediction")]
+        public static extern Status CreatePrediction(
+            this IntPtr predictor,
+            IntPtr inputs,
+            out IntPtr prediction
+        );
+        [DllImport(Assembly, EntryPoint = @"FXNPredictorStreamPrediction")]
+        public static extern Status StreamPrediction(
+            this IntPtr predictor,
+            IntPtr inputs,
+            out IntPtr stream
+        );
+        #endregion
+
+
+        #region --FXNVersion--
+        [DllImport(Assembly, EntryPoint = @"FXNGetVersion")]
+        public static extern IntPtr GetVersion();
+        #endregion
+
+
+        #region --Utilities--
+
+        public static Status Throw(this Status status) => status switch {
+            Status.Ok               => status,
+            Status.InvalidArgument  => throw new ArgumentException(),
+            Status.InvalidOperation => throw new InvalidOperationException(),
+            Status.NotImplemented   => throw new NotImplementedException(),
+            _                       => throw new InvalidOperationException(),
+        };
+        #endregion
+    }
+}

package/Runtime/C/Function.cs.meta

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

package/Runtime/C/Prediction.cs

@@ -0,0 +1,70 @@
+/* 
+*   Muna
+*   Copyright © 2025 NatML Inc. All rights reserved.
+*/
+
+#nullable enable
+
+namespace Muna.C {
+
+    using System;
+    using System.Text;
+    using static Muna;
+
+    public sealed class Prediction : IDisposable {
+
+        #region --Client API--
+
+        public string id {
+            get {
+                var id = new StringBuilder(64);
+                prediction.GetPredictionID(id, id.Capacity).Throw();
+                return id.ToString();
+            }
+        }
+
+        public double latency {
+            get {
+                prediction.GetPredictionLatency(out var latency).Throw();
+                return latency;
+            }
+        }
+
+        public ValueMap? results {
+            get {
+                var map = prediction.GetPredictionResults(out var m).Throw() == Status.Ok ?
+                    new ValueMap(m) :
+                    default;
+                return map?.size > 0 ? map : default;
+            }
+        }
+
+        public string? error {
+            get {
+                var error = new StringBuilder(2048);
+                return prediction.GetPredictionError(error, error.Capacity) == Status.Ok ? error.ToString() : null;
+            }
+        }
+
+        public string logs {
+            get {
+                prediction.GetPredictionLogLength(out var length).Throw();
+                var logs = new StringBuilder(length + 1);
+                prediction.GetPredictionLogs(logs, logs.Capacity);
+                return logs.ToString();
+            }
+        }
+
+        public void Dispose() => prediction.ReleasePrediction();
+        #endregion
+
+
+        #region --Operations--
+        private readonly IntPtr prediction;
+
+        internal Prediction(IntPtr prediction) => this.prediction = prediction;
+
+        public static implicit operator IntPtr(Prediction prediction) => prediction.prediction;
+        #endregion
+    }
+}

package/Runtime/C/Prediction.cs.meta

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

package/Runtime/C/PredictionStream.cs

@@ -0,0 +1,36 @@
+/* 
+*   Muna
+*   Copyright © 2025 NatML Inc. All rights reserved.
+*/
+
+#nullable enable
+
+namespace Muna.C {
+
+    using System;
+    using static Muna;
+
+    public sealed class PredictionStream : IDisposable {
+
+        #region --Client API--
+
+        public Prediction? ReadNext() {
+            if (stream.ReadNextPrediction(out var prediction) == Status.Ok)
+                return new Prediction(prediction);
+            else
+                return null;
+        }
+
+        public void Dispose() => stream.ReleasePredictionStream();
+        #endregion
+
+
+        #region --Operations--
+        private readonly IntPtr stream;
+
+        internal PredictionStream(IntPtr stream) => this.stream = stream;
+
+        public static implicit operator IntPtr(PredictionStream stream) => stream.stream;
+        #endregion
+    }
+}