ai.muna.muna 0.0.42

package/Runtime/C/PredictionStream.cs.meta

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

package/Runtime/C/Predictor.cs

@@ -0,0 +1,42 @@
+/* 
+*   Muna
+*   Copyright © 2025 NatML Inc. All rights reserved.
+*/
+
+#nullable enable
+
+namespace Muna.C {
+
+    using System;
+    using static Muna;
+
+    public sealed class Predictor : IDisposable {
+
+        #region --Client API--
+
+        public Predictor(Configuration configuration) {
+            CreatePredictor(configuration, out var predictor).Throw();
+            this.predictor = predictor;
+        }
+
+        public Prediction CreatePrediction(ValueMap inputs) {
+            predictor.CreatePrediction(inputs, out var prediction).Throw();
+            return new Prediction(prediction);
+        }
+
+        public PredictionStream StreamPrediction(ValueMap inputs) {
+            predictor.StreamPrediction(inputs, out var stream).Throw();
+            return new PredictionStream(stream);
+        }
+
+        public void Dispose() => predictor.ReleasePredictor();
+        #endregion
+
+
+        #region --Operations--
+        private readonly IntPtr predictor;
+
+        public static implicit operator IntPtr(Predictor predictor) => predictor.predictor;
+        #endregion
+    }
+}

package/Runtime/C/Predictor.cs.meta

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

package/Runtime/C/Value.cs

@@ -0,0 +1,194 @@
+/* 
+*   Muna
+*   Copyright © 2025 NatML Inc. All rights reserved.
+*/
+
+#nullable enable
+
+namespace Muna.C {
+
+    using System;
+    using System.Collections;
+    using System.IO;
+    using System.Linq;
+    using System.Runtime.InteropServices;
+    using Newtonsoft.Json;
+    using Newtonsoft.Json.Linq;
+    using static Muna;
+
+    public unsafe sealed class Value : IDisposable {
+
+        #region --Enumerations--
+        [Flags]
+        public enum Flags : int {
+            None = 0,
+            CopyData = 1,
+        }
+        #endregion
+
+
+        #region --Client API--
+
+        public void* data {
+            get {
+                value.GetValueData(out var data).Throw();
+                return (void*)data;
+            }
+        }
+
+        public Dtype type {
+            get {
+                value.GetValueType(out var type).Throw();
+                return type;
+            }
+        }
+
+        public int[] shape {
+            get {
+                value.GetValueDimensions(out var dims).Throw();
+                var shape = new int[dims];
+                value.GetValueShape(shape, dims).Throw();
+                return shape;
+            }
+        }
+
+        public object? ToObject() => type switch {
+            Dtype.Null      => null,
+            Dtype.Float32   => ToObject((float*)data, shape),
+            Dtype.Float64   => ToObject((double*)data, shape),
+            Dtype.Int8      => ToObject((sbyte*)data, shape),
+            Dtype.Int16     => ToObject((short*)data, shape),
+            Dtype.Int32     => ToObject((int*)data, shape),
+            Dtype.Int64     => ToObject((long*)data, shape),
+            Dtype.Uint8     => ToObject((byte*)data, shape),
+            Dtype.Uint16    => ToObject((ushort*)data, shape),
+            Dtype.Uint32    => ToObject((uint*)data, shape),
+            Dtype.Uint64    => ToObject((ulong*)data, shape),
+            Dtype.Bool      => ToObject((bool*)data, shape),
+            Dtype.String    => Marshal.PtrToStringUTF8((IntPtr)data),
+            Dtype.List      => JsonConvert.DeserializeObject<JArray>(Marshal.PtrToStringUTF8((IntPtr)data)),
+            Dtype.Dict      => JsonConvert.DeserializeObject<JObject>(Marshal.PtrToStringUTF8((IntPtr)data)),
+            Dtype.Image     => new Image(ToArray((byte*)data, shape), shape[1], shape[0], shape[2]),
+            Dtype.Binary    => new MemoryStream(ToArray((byte*)data, shape)),
+            _               => throw new InvalidOperationException($"Cannot convert Muna value to object because value type is unsupported: {type}"),
+        };
+
+        public void Dispose() => value.ReleaseValue();
+
+        public static Value CreateArray<T>(T scalar) where T : unmanaged => CreateArray(
+            new Tensor<T>(new [] { scalar }, new int[0]),
+            Flags.CopyData
+        );
+
+        public static Value CreateArray<T>(T[] vector) where T : unmanaged => CreateArray(
+            new Tensor<T>(vector, new [] { vector.Length }),
+            Flags.CopyData
+        );
+
+        public static Value CreateArray<T>(
+            in Tensor<T> tensor,
+            Flags flags = Flags.None
+        ) where T : unmanaged {
+            IntPtr value = default;
+            fixed (T* data = tensor)
+                CreateArrayValue(
+                    data,
+                    tensor.shape,
+                    tensor.shape.Length,
+                    ToDtype<T>(),
+                    flags,
+                    out value
+                ).Throw();
+            return new Value(value);
+        }
+
+        public static Value CreateString(string input) {
+            CreateStringValue(input, out var value).Throw();
+            return new Value(value);
+        }
+
+        public static Value CreateList(IList list) {
+            var json = JsonConvert.SerializeObject(list);
+            CreateListValue(json, out var value).Throw();
+            return new Value(value);
+        }
+
+        public static Value CreateDict(IDictionary dict) {
+            var json = JsonConvert.SerializeObject(dict);
+            CreateDictValue(json, out var value).Throw();
+            return new Value(value);
+        }
+
+        public static Value CreateImage(in Image image) {
+            IntPtr value = default;
+            fixed (byte* data = image)
+                CreateImageValue(
+                    data,
+                    image.width,
+                    image.height,
+                    image.channels,
+                    image.data != null ? Flags.CopyData : Flags.None,
+                    out value
+                ).Throw();
+            return new Value(value);
+        }
+
+        public static Value CreateBinary(Stream stream) {
+            byte[] data;
+            if (stream is MemoryStream memoryStream)
+                data = memoryStream.ToArray();
+            else {
+                using var dstStream = new MemoryStream();
+                stream.CopyTo(dstStream);
+                data = dstStream.ToArray();
+            }
+            CreateBinaryValue(data, data.Length, Flags.CopyData, out var value).Throw();
+            return new Value(value);
+        }
+
+        public static Value CreateNull() {
+            CreateNullValue(out var value).Throw();
+            return new Value(value);
+        }
+        #endregion
+
+
+        #region --Operations--
+        private readonly IntPtr value;
+
+        internal Value(IntPtr value) => this.value = value;
+
+        public static implicit operator IntPtr(Value value) => value.value;
+
+        private static unsafe object ToObject<T>(T* data, int[] shape) where T : unmanaged {
+            if (shape.Length == 0)
+                return *(T*)data;
+            var array = ToArray(data, shape);
+            return new Tensor<T>(array, shape);
+        }
+
+        private static unsafe T[] ToArray<T>(T* data, int[] shape) where T : unmanaged {
+            var count = shape.Aggregate(1, (a, b) => a * b);
+            var result = new T[count];
+            fixed (void* dst = result)
+                Buffer.MemoryCopy(data, dst, count * sizeof(T), count * sizeof(T));
+            return result;
+        }
+
+        private static Dtype ToDtype<T>() where T : unmanaged => default(T) switch { // don't use this for reference types
+            float   _ => Dtype.Float32,
+            double  _ => Dtype.Float64,
+            sbyte   _ => Dtype.Int8,
+            short   _ => Dtype.Int16,
+            int     _ => Dtype.Int32,
+            long    _ => Dtype.Int64,
+            byte    _ => Dtype.Uint8,
+            ushort  _ => Dtype.Uint16,
+            uint    _ => Dtype.Uint32,
+            ulong   _ => Dtype.Uint64,
+            bool    _ => Dtype.Bool,
+                    _ => Dtype.Null,
+        };
+        #endregion
+    }
+}

package/Runtime/C/Value.cs.meta

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

package/Runtime/C/ValueMap.cs

@@ -0,0 +1,50 @@
+/* 
+*   Muna
+*   Copyright © 2025 NatML Inc. All rights reserved.
+*/
+
+#nullable enable
+
+namespace Muna.C {
+
+    using System;
+    using System.Text;
+    using static Muna;
+
+    public sealed class ValueMap : IDisposable {
+
+        #region --Client API--
+
+        public Value this[string key] {
+            get => GetValue(key);
+            set => map.SetValueMapValue(key, value).Throw();
+        }
+
+        public int size => map.GetValueMapSize(out var size).Throw() == Status.Ok ? size : default;
+
+        public ValueMap() : this(CreateValueMap(out var map).Throw() == Status.Ok ? map : default) { }
+
+        public string GetKey(int index) {
+            var key = new StringBuilder(2048);
+            map.GetValueMapKey(index, key, key.Capacity).Throw();
+            return key.ToString();
+        }
+
+        public Value GetValue(string key) {
+            map.GetValueMapValue(key, out var value).Throw();
+            return new Value(value);
+        }
+
+        public void Dispose () => map.ReleaseValueMap();
+        #endregion
+
+
+        #region --Operations--
+        private readonly IntPtr map;
+
+        internal ValueMap(IntPtr map) => this.map = map;
+
+        public static implicit operator IntPtr(ValueMap map) => map.map;
+        #endregion
+    }
+}

package/Runtime/C/ValueMap.cs.meta

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

package/Runtime/C.meta

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

package/Runtime/Muna.Runtime.asmdef

@@ -0,0 +1,27 @@
+{
+    "name": "Muna.Runtime",
+    "rootNamespace": "",
+    "references": [],
+    "includePlatforms": [
+        "Android",
+        "Editor",
+        "EmbeddedLinux",
+        "iOS",
+        "LinuxStandalone64",
+        "CloudRendering",
+        "macOSStandalone",
+        "VisionOS",
+        "WebGL",
+        "WindowsStandalone64"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": true,
+    "overrideReferences": true,
+    "precompiledReferences": [
+        "Newtonsoft.Json.dll"
+    ],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": true
+}

package/Runtime/Muna.Runtime.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 37bdf37a8cd194eec97725698ffe0640
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Muna.cs

@@ -0,0 +1,109 @@
+/* 
+*   Muna
+*   Copyright © 2025 NatML Inc. All rights reserved.
+*/
+
+#nullable enable
+
+using System.Reflection;
+using System.Runtime.CompilerServices;
+
+[assembly: AssemblyCompany(@"NatML Inc.")]
+[assembly: AssemblyTitle(@"Muna.Runtime")]
+[assembly: AssemblyVersion(Muna.Muna.Version)]
+[assembly: AssemblyCopyright(@"Copyright © 2025 NatML Inc. All Rights Reserved.")]
+[assembly: InternalsVisibleTo(@"Muna.Unity")]
+[assembly: InternalsVisibleTo(@"Muna.Editor")]
+[assembly: InternalsVisibleTo(@"Muna.Tests.Editor")]
+[assembly: InternalsVisibleTo(@"Muna.Tests.Runtime")]
+
+namespace Muna {
+
+    using System;
+    using API;
+    using Beta;
+    using Services;
+
+    /// <summary>
+    /// Muna client.
+    /// </summary>
+    public sealed class Muna {
+
+        #region --Attributes--
+        /// <summary>
+        /// Embed predictors at build time to avoid errors due to sandboxing restrictions.
+        /// NOTE: This is required to use edge predictors on Android and iOS.
+        /// </summary>
+        [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Property, AllowMultiple = false, Inherited = false)]
+        public sealed class EmbedAttribute : Attribute {
+
+            internal readonly string[] tags;
+            
+            /// <summary>
+            /// Embed predictors at build time.
+            /// </summary>
+            public EmbedAttribute(params string[] tags) => this.tags = tags;
+        }
+        #endregion
+
+
+        #region --Client API--
+        /// <summary>
+        /// Manage users.
+        /// </summary>
+        public readonly UserService Users;
+
+        /// <summary>
+        /// Manage predictors.
+        /// </summary>
+        public readonly PredictorService Predictors;
+
+        /// <summary>
+        /// Make predictions.
+        /// </summary>
+        public readonly PredictionService Predictions;
+
+        /// <summary>
+        /// Beta client for incubating features.
+        /// </summary>
+        public readonly BetaClient Beta;
+
+        /// <summary>
+        /// Create a Muna client.
+        /// </summary>
+        /// <param name="accessKey">Muna access key.</param>
+        /// <param name="url">Muna API URL.</param>
+        public Muna(
+            string? accessKey = null,
+            string? url = null
+        ) : this(new DotNetClient(url ?? URL, accessKey: accessKey)) { }
+
+        /// <summary>
+        /// Create a Muna client.
+        /// </summary>
+        /// <param name="client">Muna API client.</param>
+        public Muna(MunaClient client) {
+            this.client = client;
+            this.Users = new UserService(client);
+            this.Predictors = new PredictorService(client);
+            this.Predictions = new PredictionService(client);
+            this.Beta = new BetaClient(client);
+        }
+        #endregion
+
+
+        #region --Operations--
+        public readonly MunaClient client;
+        public const string Version = @"0.0.42";
+        internal const string URL = @"https://api.muna.ai/v1";
+        #endregion
+    }
+
+    [AttributeUsage(AttributeTargets.All, Inherited = true, AllowMultiple = false)]
+    internal sealed class PreserveAttribute : Attribute { }
+
+    [AttributeUsage(AttributeTargets.Method, AllowMultiple = true)]
+    internal sealed class MonoPInvokeCallbackAttribute : Attribute {
+        public MonoPInvokeCallbackAttribute(Type type) {}
+    }
+}

package/Runtime/Muna.cs.meta

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