Reduced memory usage and fixed several memory leaks (#933)

app/MindWork AI Studio/Tools/PluginSystem/PluginBase.cs

@@ -6,7 +6,7 @@ namespace AIStudio.Tools.PluginSystem;
 /// <summary>
 /// Represents the base of any AI Studio plugin.
 /// </summary>
-public abstract partial class PluginBase : IPluginMetadata
+public abstract partial class PluginBase : IPluginMetadata, IDisposable
 {
     private static string TB(string fallbackEN) => I18N.I.T(fallbackEN, typeof(PluginBase).Namespace, nameof(PluginBase));
     
@@ -546,4 +546,18 @@ public abstract partial class PluginBase : IPluginMetadata
     }
 
     #endregion
+
+    #region Implementation of IDisposable
+
+    /// <summary>
+    /// Releases the Lua runtime of this plugin.
+    /// </summary>
+    /// <remarks>
+    /// Every plugin owns a Lua state, which is an entire scripting runtime. Dropping a plugin
+    /// without disposing it leaves that runtime behind: before this existed, each hot reload added
+    /// another set of them for as long as the app was running.
+    /// </remarks>
+    public void Dispose() => this.State.Dispose();
+
+    #endregion
 }

app/MindWork AI Studio/Tools/PluginSystem/PluginFactory.HotReload.cs

@@ -21,6 +21,16 @@ public static partial class PluginFactory
         AutoReset = false,
     };
 
+    /// <summary>
+    /// Whether hot reloading was set up already.
+    /// </summary>
+    /// <remarks>
+    /// The timer and the watcher are static, while this method is called from a component. Calling
+    /// it twice would add a second handler to each of them, and every change in the plugins
+    /// directory would then trigger as many reloads as there were calls.
+    /// </remarks>
+    private static bool IS_HOT_RELOADING_SET_UP;
+
     public static void SetUpHotReloading()
     {
         if (!IsInitialized)
@@ -29,6 +39,14 @@ public static partial class PluginFactory
             return;
         }
 
+        if (IS_HOT_RELOADING_SET_UP)
+        {
+            LOG.LogInformation("Hot reloading is already set up. Skipping.");
+            return;
+        }
+
+        IS_HOT_RELOADING_SET_UP = true;
+
         LOG.LogInformation($"Start hot reloading plugins for path '{HOT_RELOAD_WATCHER.Path}'.");
         try
         {

app/MindWork AI Studio/Tools/PluginSystem/PluginFactory.Remove.cs

@@ -69,8 +69,13 @@ public static partial class PluginFactory
             AVAILABLE_PLUGINS.Remove(plugin);
 
             if (RUNNING_PLUGINS.FirstOrDefault(runningPlugin => runningPlugin.Id == plugin.Id) is { } runningPluginToRemove)
+            {
                 RUNNING_PLUGINS.Remove(runningPluginToRemove);
 
+                // The plugin is unloaded, so its Lua runtime is of no use anymore:
+                runningPluginToRemove.Dispose();
+            }
+
             LOG.LogInformation("Unloaded the plugin '{PluginName}' ({PluginId}). Reason: {Reason}.", plugin.Name, plugin.Id, reason);
         }
 

app/MindWork AI Studio/Tools/PluginSystem/PluginFactory.Starting.cs

@@ -18,6 +18,15 @@ public static partial class PluginFactory
     {
         LOG.LogInformation("Try to start or restart all plugins.");
         var configObjects = new List<PluginConfigurationObject>();
+
+        //
+        // Dropping the plugins is not enough: each one owns a Lua runtime, which we have to release
+        // ourselves. Otherwise, every restart — above all every hot reload during development —
+        // leaves another set of runtimes behind:
+        //
+        foreach (var runningPlugin in RUNNING_PLUGINS)
+            runningPlugin.Dispose();
+
         RUNNING_PLUGINS.Clear();
 
         //