Memory usage investigation

src/10-Core/Wtq/Services/Stubs/ServiceCollectionExtensions.cs

@@ -0,0 +1,15 @@
+using Microsoft.Extensions.DependencyInjection;
+
+namespace Wtq.Services.Stubs;
+
+public static class ServiceCollectionExtensions
+{
+	public static IServiceCollection AddStubs(this IServiceCollection services)
+	{
+		Guard.Against.Null(services);
+
+		return services
+			.AddSingleton<IWtqWindowService, StubWtqWindowService>()
+			.AddSingleton<IWtqScreenInfoProvider, StubWtqScreenInfoProvider>();
+	}
+}

src/10-Core/Wtq/Services/Stubs/StubWtqScreenInfoProvider.cs

@@ -0,0 +1,19 @@
+namespace Wtq.Services.Stubs;
+
+public class StubWtqScreenInfoProvider : IWtqScreenInfoProvider
+{
+	public Task<Rectangle> GetPrimaryScreenRectAsync()
+	{
+		return Task.FromResult(new Rectangle(0, 0, 1920, 1080));
+	}
+
+	public Task<Rectangle[]> GetScreenRectsAsync()
+	{
+		return Task.FromResult<Rectangle[]>([new Rectangle(0, 0, 1920, 1080)]);
+	}
+
+	public Task<Rectangle> GetScreenWithCursorAsync()
+	{
+		return Task.FromResult(new Rectangle(0, 0, 1920, 1080));
+	}
+}

src/10-Core/Wtq/Services/Stubs/StubWtqWindowService.cs

@@ -0,0 +1,29 @@
+namespace Wtq.Services.Stubs;
+
+public class StubWtqWindowService : IWtqWindowService
+{
+	public Task CreateAsync(WtqAppOptions opts, CancellationToken cancellationToken)
+	{
+		return Task.CompletedTask;
+	}
+
+	public Task<ICollection<WtqWindow>> FindWindowsAsync(WtqAppOptions opts, CancellationToken cancellationToken)
+	{
+		return Task.FromResult<ICollection<WtqWindow>>([]);
+	}
+
+	public Task<WtqWindow?> GetForegroundWindowAsync(CancellationToken cancellationToken)
+	{
+		return Task.FromResult<WtqWindow?>(null);
+	}
+
+	public List<WtqWindowProperty> GetWindowProperties()
+	{
+		return [];
+	}
+
+	public Task<ICollection<WtqWindow>> GetWindowsAsync(CancellationToken cancellationToken)
+	{
+		return Task.FromResult<ICollection<WtqWindow>>([]);
+	}
+}

src/10-Core/Wtq/Utils/Log.cs

@@ -40,7 +40,7 @@ public static void Configure(string pathToLogsDir)
 				restrictedToMinimumLevel: LogLevel)
 
 			// In-app.
-			.WriteTo.Sink(InAppLogSink.Instance)
+			// .WriteTo.Sink(InAppLogSink.Instance)
 
 			// Plain text.
 			.WriteTo.File(

src/20-Services/Wtq.Services.UI/WtqUIHostBuilder.cs

@@ -10,7 +10,19 @@ namespace Wtq.Services.UI;
 
 public static class WtqUIHostBuilder
 {
-	public static void Run(Action<IServiceCollection> services)
+	public static void Run(Action<IServiceCollection> services, bool gui)
+	{
+		if (gui)
+		{
+			RunGui(services);
+		}
+		else
+		{
+			RunHeadless(services);
+		}
+	}
+
+	public static void RunGui(Action<IServiceCollection> services)
 	{
 		Guard.Against.Null(services);
 
@@ -60,4 +72,52 @@ public static void Run(Action<IServiceCollection> services)
 
 		app.Run();
 	}
+
+	public static void RunHeadless(Action<IServiceCollection> services)
+	{
+		Guard.Against.Null(services);
+
+		var s = new ServiceCollection();
+
+		using var invoker = new WtqUIInvoker();
+
+		s
+			.AddLogging()
+			.AddSingleton<IHostApplicationLifetime, ApplicationLifetime>()
+			.AddSingleton<IWtqUIService>(_ => invoker)
+		;
+
+		services(s);
+
+		var p = s.BuildServiceProvider();
+
+		var lifetime = (ApplicationLifetime)p.GetRequiredService<IHostApplicationLifetime>();
+
+		// Note that this handler needs to be called pretty early, otherwise other handles may be run first, like the AspNetCore one (if the API is enabled).
+		// Note that we shouldn't ignore the return value, as it can get optimized out in "Release" mode, causing the entire handler to not work (as it gets finalized immediately).
+		using var reg = PosixSignalRegistration.Create(
+			PosixSignal.SIGINT,
+			ctx =>
+			{
+				ctx.Cancel = true;
+
+				lifetime.StopApplication(); // "Stopping"
+			});
+
+		invoker.Action = a => a();
+
+		_ = new WtqHost(
+			lifetime,
+			p.GetRequiredService<IEnumerable<IHostedService>>(),
+			p.GetRequiredService<IPlatformService>(),
+			() => {});
+
+		lifetime.NotifyStarted();
+
+		var exit = new TaskCompletionSource();
+
+		lifetime.ApplicationStopped.Register(() => exit.SetResult());
+
+		exit.Task.GetAwaiter().GetResult();
+	}
 }

src/30-Host/Wtq.Host.Base/ConfigurationExtensions.cs

@@ -34,7 +34,7 @@ private static IConfiguration CreateConfigurationRoot(IPlatformService platform,
 		var pathToWtqConf = platform.PathToWtqConf;
 
 		// Write wtq.schema.json.
-		WtqSchema.WriteFor(pathToWtqConf);
+		WtqSchema.WriteFor(pathToWtqConf); // ~40MB
 
 		// Load config file.
 		var config = new ConfigurationBuilder()

src/30-Host/Wtq.Host.Base/WtqHostBase.cs

@@ -16,7 +16,7 @@ public async Task RunAsync(string[] args)
 		var platform = CreatePlatformService();
 
 		// Setup logging ASAP, so we can log stuff if initialization goes awry.
-		Log.Configure(platform.PathToLogsDir);
+		Log.Configure(platform.PathToLogsDir); // ~25MB
 
 		if (args.Length == 0)
 		{
@@ -75,10 +75,11 @@ private void RunApp(IPlatformService platform, string[] args)
 					.AddConfiguration(platform, args)
 					.AddApi()
 					.AddUI()
-					.AddWtqCore();
+					.AddWtqCore()
+				;
 
 				ConfigureServices(s);
-			});
+			}, gui: false);
 		}
 		catch (Exception ex)
 		{

src/30-Host/Wtq.Host.Linux/Properties/launchSettings.json

@@ -5,7 +5,10 @@
 			"environmentVariables": {
 				"WEBKIT_DISABLE_DMABUF_RENDERER": "1",
 
-				"__WTQ_LOG_LEVEL": "VERBOSE"
+				"__WTQ_LOG_LEVEL": "VERBOSE",
+				"__DOTNET_DefaultStackSize": "100000",
+				"__DOTNET_GCHeapHardLimit": "0x10000000",
+				"__DOTNET_GCHeapCount": "2"
 			}
 		},
 		"Config From User Home": {

src/Directory.Build.props

@@ -5,6 +5,8 @@
 		<TargetFramework>net10.0</TargetFramework>
 		<Nullable>enable</Nullable>
 
+		<InvariantGlobalization>true</InvariantGlobalization>
+
 		<!-- Some features we use require a documentation file, like analyzers, and the docs manifest generation -->
 		<GenerateDocumentationFile>true</GenerateDocumentationFile>