Update Akka.NET to 1.5.51 & use per-actor timers

Agent/Phantom.Agent.Minecraft.Tests/Java/JavaPropertiesStreamTests.cs

@@ -0,0 +1,289 @@
+using System.Collections.Immutable;
+using NUnit.Framework;
+using Phantom.Agent.Minecraft.Java;
+using Phantom.Utils.Collections;
+
+namespace Phantom.Agent.Minecraft.Tests.Java;
+
+[TestFixture]
+public sealed class JavaPropertiesStreamTests {
+	public sealed class Reader {
+		private static async Task<ImmutableArray<KeyValuePair<string, string>>> Parse(string contents) {
+			using var stream = new MemoryStream(JavaPropertiesStream.Encoding.GetBytes(contents));
+			using var properties = new JavaPropertiesStream.Reader(stream);
+			return await properties.ReadProperties(CancellationToken.None).ToImmutableArrayAsync();
+		}
+		
+		private static ImmutableArray<KeyValuePair<string, string>> KeyValue(string key, string value) {
+			return [new KeyValuePair<string, string>(key, value)];
+		}
+		
+		[TestCase("")]
+		[TestCase("\n")]
+		public async Task EmptyLinesAreIgnored(string contents) {
+			Assert.That(await Parse(contents), Is.EquivalentTo(ImmutableArray<KeyValuePair<string, string>>.Empty));
+		}
+		
+		[TestCase("# Comment")]
+		[TestCase("! Comment")]
+		[TestCase("# Comment\n! Comment")]
+		public async Task CommentsAreIgnored(string contents) {
+			Assert.That(await Parse(contents), Is.EquivalentTo(ImmutableArray<KeyValuePair<string, string>>.Empty));
+		}
+		
+		[TestCase("key=value")]
+		[TestCase("key= value")]
+		[TestCase("key =value")]
+		[TestCase("key = value")]
+		[TestCase("key:value")]
+		[TestCase("key: value")]
+		[TestCase("key :value")]
+		[TestCase("key : value")]
+		[TestCase("key value")]
+		[TestCase("key\tvalue")]
+		[TestCase("key\fvalue")]
+		[TestCase("key \t\fvalue")]
+		public async Task SimpleKeyValue(string contents) {
+			Assert.That(await Parse(contents), Is.EquivalentTo(KeyValue("key", "value")));
+		}
+		
+		[TestCase("key")]
+		[TestCase(" key")]
+		[TestCase(" key ")]
+		[TestCase("key=")]
+		[TestCase("key:")]
+		public async Task KeyWithoutValue(string contents) {
+			Assert.That(await Parse(contents), Is.EquivalentTo(KeyValue("key", "")));
+		}
+		
+		[TestCase(@"\#key=value", "#key")]
+		[TestCase(@"\!key=value", "!key")]
+		public async Task KeyBeginsWithEscapedComment(string contents, string expectedKey) {
+			Assert.That(await Parse(contents), Is.EquivalentTo(KeyValue(expectedKey, "value")));
+		}
+		
+		[TestCase(@"\=key=value", "=key")]
+		[TestCase(@"\:key=value", ":key")]
+		[TestCase(@"\ key=value", " key")]
+		[TestCase("\\\tkey=value", "\tkey")]
+		[TestCase("\\\fkey=value", "\fkey")]
+		public async Task KeyBeginsWithEscapedDelimiter(string contents, string expectedKey) {
+			Assert.That(await Parse(contents), Is.EquivalentTo(KeyValue(expectedKey, "value")));
+		}
+		
+		[TestCase(@"start\=end=value", "start=end")]
+		[TestCase(@"start\:end:value", "start:end")]
+		[TestCase(@"start\ end value", "start end")]
+		[TestCase(@"start\ \:\=end = value", "start :=end")]
+		[TestCase("start\\ \\\t\\\fend = value", "start \t\fend")]
+		public async Task KeyContainsEscapedDelimiter(string contents, string expectedKey) {
+			Assert.That(await Parse(contents), Is.EquivalentTo(KeyValue(expectedKey, "value")));
+		}
+		
+		[TestCase(@"key = \ value", " value")]
+		[TestCase("key = \\\tvalue", "\tvalue")]
+		[TestCase("key = \\\fvalue", "\fvalue")]
+		[TestCase("key=\\ \\\t\\\fvalue", " \t\fvalue")]
+		public async Task ValueBeginsWithEscapedWhitespace(string contents, string expectedValue) {
+			Assert.That(await Parse(contents), Is.EquivalentTo(KeyValue("key", expectedValue)));
+		}
+		
+		[TestCase(@"key = value\", "value")]
+		public async Task ValueEndsWithTrailingBackslash(string contents, string expectedValue) {
+			Assert.That(await Parse(contents), Is.EquivalentTo(KeyValue("key", expectedValue)));
+		}
+		
+		[TestCase("key=\\\0", "\0")]
+		[TestCase(@"key=\\", "\\")]
+		[TestCase(@"key=\t", "\t")]
+		[TestCase(@"key=\n", "\n")]
+		[TestCase(@"key=\r", "\r")]
+		[TestCase(@"key=\f", "\f")]
+		[TestCase(@"key=\u3053\u3093\u306b\u3061\u306f", "こんにちは")]
+		[TestCase(@"key=\u3053\u3093\u306B\u3061\u306F", "こんにちは")]
+		[TestCase("key=\\\0\\\\\\t\\n\\r\\f\\u3053", "\0\\\t\n\r\fこ")]
+		public async Task ValueContainsEscapedSpecialCharacters(string contents, string expectedValue) {
+			Assert.That(await Parse(contents), Is.EquivalentTo(KeyValue("key", expectedValue)));
+		}
+		
+		[TestCase("key=first\\\nsecond", "first\nsecond")]
+		[TestCase("key=first\\\n    second", "first\nsecond")]
+		[TestCase("key=first\\\n#second", "first\n#second")]
+		[TestCase("key=first\\\n!second", "first\n!second")]
+		public async Task ValueContainsNewLine(string contents, string expectedValue) {
+			Assert.That(await Parse(contents), Is.EquivalentTo(KeyValue("key", expectedValue)));
+		}
+		
+		[TestCase("key=first\\\n    \\ second", "first\n second")]
+		[TestCase("key=first\\\n    \\\tsecond", "first\n\tsecond")]
+		[TestCase("key=first\\\n    \\\fsecond", "first\n\fsecond")]
+		[TestCase("key=first\\\n \t\f\\ second", "first\n second")]
+		public async Task ValueContainsNewLineWithEscapedLeadingWhitespace(string contents, string expectedValue) {
+			Assert.That(await Parse(contents), Is.EquivalentTo(KeyValue("key", expectedValue)));
+		}
+		
+		[Test]
+		public async Task ExampleFile() {
+			// From Wikipedia: https://en.wikipedia.org/wiki/.properties
+			const string ExampleFile = """
+			                           # You are reading a comment in ".properties" file.
+			                           ! The exclamation mark ('!') can also be used for comments.
+			                           # Comments are ignored.
+			                           # Blank lines are also ignored.
+			                           
+			                           # Lines with "properties" contain a key and a value separated by a delimiting character.
+			                           # There are 3 delimiting characters: equal ('='), colon (':') and whitespace (' ', '\t' and '\f').
+			                           website = https://en.wikipedia.org/
+			                           language : English
+			                           topic .properties files
+			                           # A word on a line will just create a key with no value.
+			                           empty
+			                           # Whitespace that appears between the key, the delimiter and the value is ignored.
+			                           # This means that the following are equivalent (other than for readability).
+			                           hello=hello
+			                           hello = hello
+			                           # To start the value with whitespace, escape it with a backslash ('\').
+			                           whitespaceStart = \ <-This space is not ignored.
+			                           # Keys with the same name will be overwritten by the key that is the furthest in a file.
+			                           # For example the final value for "duplicateKey" will be "second".
+			                           duplicateKey = first
+			                           duplicateKey = second
+			                           # To use the delimiter characters inside a key, you need to escape them with a ('\').
+			                           # However, there is no need to do this in the value.
+			                           delimiterCharacters\:\=\ = This is the value for the key "delimiterCharacters\:\=\ "
+			                           # Adding a backslash ('\') at the end of a line means that the value continues on the next line.
+			                           multiline = This line \
+			                           continues
+			                           # If you want your value to include a backslash ('\'), it should be escaped by another backslash ('\').
+			                           path = c:\\wiki\\templates
+			                           # This means that if the number of backslashes ('\') at the end of the line is even, the next line is not included in the value. 
+			                           # In the following example, the value for "evenKey" is "This is on one line\".
+			                           evenKey = This is on one line\\
+			                           # This line is a normal comment and is not included in the value for "evenKey".
+			                           # If the number of backslash ('\') is odd, then the next line is included in the value.
+			                           # In the following example, the value for "oddKey" is "This is line one and\# This is line two".
+			                           oddKey = This is line one and\\\
+			                           # This is line two
+			                           # Whitespace characters at the beginning of a line is removed.
+			                           # Make sure to add the spaces you need before the backslash ('\') on the first line. 
+			                           # If you add them at the beginning of the next line, they will be removed.
+			                           # In the following example, the value for "welcome" is "Welcome to Wikipedia!".
+			                           welcome = Welcome to \
+			                                     Wikipedia!
+			                           # If you need to add newlines and carriage returns, they need to be escaped using ('\n') and ('\r') respectively.
+			                           # You can also optionally escape tabs with ('\t') for readability purposes.
+			                           valueWithEscapes = This is a newline\n and a carriage return\r and a tab\t.
+			                           # You can also use Unicode escape characters (maximum of four hexadecimal digits).
+			                           # In the following example, the value for "encodedHelloInJapanese" is "こんにちは".
+			                           encodedHelloInJapanese = \u3053\u3093\u306b\u3061\u306f
+			                           """;
+			
+			ImmutableArray<KeyValuePair<string, string>> result = [
+				new ("website", "https://en.wikipedia.org/"),
+				new ("language", "English"),
+				new ("topic", ".properties files"),
+				new ("empty", ""),
+				new ("hello", "hello"),
+				new ("hello", "hello"),
+				new ("whitespaceStart", @" <-This space is not ignored."),
+				new ("duplicateKey", "first"),
+				new ("duplicateKey", "second"),
+				new ("delimiterCharacters:= ", @"This is the value for the key ""delimiterCharacters:= """),
+				new ("multiline", "This line \ncontinues"),
+				new ("path", @"c:\wiki\templates"),
+				new ("evenKey", @"This is on one line\"),
+				new ("oddKey", "This is line one and\\\n# This is line two"),
+				new ("welcome", "Welcome to \nWikipedia!"),
+				new ("valueWithEscapes", "This is a newline\n and a carriage return\r and a tab\t."),
+				new ("encodedHelloInJapanese", "こんにちは"),
+			];
+			
+			Assert.That(await Parse(ExampleFile), Is.EquivalentTo(result));
+		}
+	}
+	
+	public sealed class Writer {
+		private static async Task<string> Write(Func<JavaPropertiesStream.Writer, Task> write) {
+			using var stream = new MemoryStream();
+			
+			await using (var writer = new JavaPropertiesStream.Writer(stream)) {
+				await write(writer);
+			}
+			
+			return JavaPropertiesStream.Encoding.GetString(stream.ToArray());
+		}
+		
+		[TestCase("one line comment", "# one line comment\n")]
+		[TestCase("こんにちは", "# \\u3053\\u3093\\u306B\\u3061\\u306F\n")]
+		[TestCase("first line\nsecond line\r\nthird line", "# first line\n# second line\n# third line\n")]
+		public async Task Comment(string comment, string contents) {
+			Assert.That(await Write(writer => writer.WriteComment(comment, CancellationToken.None)), Is.EqualTo(contents));
+		}
+		
+		[TestCase("key", "value", "key=value\n")]
+		[TestCase("key", "", "key=\n")]
+		[TestCase("", "value", "=value\n")]
+		public async Task SimpleKeyValue(string key, string value, string contents) {
+			Assert.That(await Write(writer => writer.WriteProperty(key, value, CancellationToken.None)), Is.EqualTo(contents));
+		}
+		
+		[TestCase("#key", "value", "\\#key=value\n")]
+		[TestCase("!key", "value", "\\!key=value\n")]
+		public async Task KeyBeginsWithEscapedComment(string key, string value, string contents) {
+			Assert.That(await Write(writer => writer.WriteProperty(key, value, CancellationToken.None)), Is.EqualTo(contents));
+		}
+		
+		[TestCase("=key", "value", "\\=key=value\n")]
+		[TestCase(":key", "value", "\\:key=value\n")]
+		[TestCase(" key", "value", "\\ key=value\n")]
+		[TestCase("\tkey", "value", "\\tkey=value\n")]
+		[TestCase("\fkey", "value", "\\fkey=value\n")]
+		public async Task KeyBeginsWithEscapedDelimiter(string key, string value, string contents) {
+			Assert.That(await Write(writer => writer.WriteProperty(key, value, CancellationToken.None)), Is.EqualTo(contents));
+		}
+		
+		[TestCase("start=end", "value", "start\\=end=value\n")]
+		[TestCase("start:end", "value", "start\\:end=value\n")]
+		[TestCase("start end", "value", "start\\ end=value\n")]
+		[TestCase("start :=end", "value", "start\\ \\:\\=end=value\n")]
+		[TestCase("start \t\fend", "value", "start\\ \\t\\fend=value\n")]
+		public async Task KeyContainsEscapedDelimiter(string key, string value, string contents) {
+			Assert.That(await Write(writer => writer.WriteProperty(key, value, CancellationToken.None)), Is.EqualTo(contents));
+		}
+		
+		[TestCase("\\", "value", "\\\\=value\n")]
+		[TestCase("\t", "value", "\\t=value\n")]
+		[TestCase("\n", "value", "\\n=value\n")]
+		[TestCase("\r", "value", "\\r=value\n")]
+		[TestCase("\f", "value", "\\f=value\n")]
+		[TestCase("こんにちは", "value", "\\u3053\\u3093\\u306B\\u3061\\u306F=value\n")]
+		[TestCase("\\\t\n\r\fこ", "value", "\\\\\\t\\n\\r\\f\\u3053=value\n")]
+		[TestCase("first-line\nsecond-line\r\nthird-line", "value", "first-line\\nsecond-line\\r\\nthird-line=value\n")]
+		public async Task KeyContainsEscapedSpecialCharacters(string key, string value, string contents) {
+			Assert.That(await Write(writer => writer.WriteProperty(key, value, CancellationToken.None)), Is.EqualTo(contents));
+		}
+		
+		[TestCase("key", "\\", "key=\\\\\n")]
+		[TestCase("key", "\t", "key=\\t\n")]
+		[TestCase("key", "\n", "key=\\n\n")]
+		[TestCase("key", "\r", "key=\\r\n")]
+		[TestCase("key", "\f", "key=\\f\n")]
+		[TestCase("key", "こんにちは", "key=\\u3053\\u3093\\u306B\\u3061\\u306F\n")]
+		[TestCase("key", "\\\t\n\r\fこ", "key=\\\\\\t\\n\\r\\f\\u3053\n")]
+		[TestCase("key", "first line\nsecond line\r\nthird line", "key=first line\\nsecond line\\r\\nthird line\n")]
+		public async Task ValueContainsEscapedSpecialCharacters(string key, string value, string contents) {
+			Assert.That(await Write(writer => writer.WriteProperty(key, value, CancellationToken.None)), Is.EqualTo(contents));
+		}
+		
+		[Test]
+		public async Task ExampleFile() {
+			string contents = await Write(static async writer => {
+				await writer.WriteComment("Comment", CancellationToken.None);
+				await writer.WriteProperty("key", "value", CancellationToken.None);
+				await writer.WriteProperty("multiline", "first line\nsecond line", CancellationToken.None);
+			});
+			
+			Assert.That(contents, Is.EqualTo("# Comment\nkey=value\nmultiline=first line\\nsecond line\n"));
+		}
+	}
+}

Agent/Phantom.Agent.Minecraft.Tests/Phantom.Agent.Minecraft.Tests.csproj

@@ -0,0 +1,23 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  
+  <PropertyGroup>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+  
+  <PropertyGroup>
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+  
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" />
+    <PackageReference Include="NUnit" />
+    <PackageReference Include="NUnit3TestAdapter" />
+    <PackageReference Include="NUnit.Analyzers" />
+  </ItemGroup>
+  
+  <ItemGroup>
+    <ProjectReference Include="..\Phantom.Agent.Minecraft\Phantom.Agent.Minecraft.csproj" />
+  </ItemGroup>
+
+</Project>

Agent/Phantom.Agent.Minecraft/Java/JavaPropertiesFileEditor.cs

@@ -1,92 +1,52 @@
-using System.Text;
-using Kajabity.Tools.Java;
-
-namespace Phantom.Agent.Minecraft.Java;
+namespace Phantom.Agent.Minecraft.Java;
 
 sealed class JavaPropertiesFileEditor {
-	private static readonly Encoding Encoding = Encoding.GetEncoding("ISO-8859-1");
-	
 	private readonly Dictionary<string, string> overriddenProperties = new ();
 	
 	public void Set(string key, string value) {
 		overriddenProperties[key] = value;
 	}
 	
-	public async Task EditOrCreate(string filePath) {
+	public async Task EditOrCreate(string filePath, string comment, CancellationToken cancellationToken) {
 		if (File.Exists(filePath)) {
 			string tmpFilePath = filePath + ".tmp";
-			File.Copy(filePath, tmpFilePath, overwrite: true);
-			await EditFromCopyOrCreate(filePath, tmpFilePath);
+			await Edit(filePath, tmpFilePath, comment, cancellationToken);
 			File.Move(tmpFilePath, filePath, overwrite: true);
 		}
 		else {
-			await EditFromCopyOrCreate(sourceFilePath: null, filePath);
+			await Create(filePath, comment, cancellationToken);
 		}
 	}
 	
-	private async Task EditFromCopyOrCreate(string? sourceFilePath, string targetFilePath) {
-		var properties = new JavaProperties();
+	private async Task Create(string targetFilePath, string comment, CancellationToken cancellationToken) {
+		await using var targetWriter = new JavaPropertiesStream.Writer(targetFilePath);
 		
-		if (sourceFilePath != null) {
-			// TODO replace with custom async parser
-			await using var sourceStream = new FileStream(sourceFilePath, FileMode.Open, FileAccess.Read, FileShare.Read);
-			properties.Load(sourceStream, Encoding);
-		}
+		await targetWriter.WriteComment(comment, cancellationToken);
 		
-		foreach (var (key, value) in overriddenProperties) {
-			properties[key] = value;
-		}
-		
-		await using var targetStream = new FileStream(targetFilePath, FileMode.Create, FileAccess.Write, FileShare.Read);
-		await using var targetWriter = new StreamWriter(targetStream, Encoding);
-		
-		await targetWriter.WriteLineAsync("# Properties");
-		
-		foreach (var (key, value) in properties) {
-			await WriteProperty(targetWriter, key, value);
+		foreach ((string key, string value) in overriddenProperties) {
+			await targetWriter.WriteProperty(key, value, cancellationToken);
 		}
 	}
 	
-	private static async Task WriteProperty(StreamWriter writer, string key, string value) {
-		await WritePropertyComponent(writer, key, escapeSpaces: true);
-		await writer.WriteAsync('=');
-		await WritePropertyComponent(writer, value, escapeSpaces: false);
-		await writer.WriteLineAsync();
-	}
+	private async Task Edit(string sourceFilePath, string targetFilePath, string comment, CancellationToken cancellationToken) {
+		using var sourceReader = new JavaPropertiesStream.Reader(sourceFilePath);
+		await using var targetWriter = new JavaPropertiesStream.Writer(targetFilePath);
 		
-	private static async Task WritePropertyComponent(TextWriter writer, string component, bool escapeSpaces) {
-		for (int index = 0; index < component.Length; index++) {
-			var c = component[index];
-			switch (c) {
-				case '\\':
-				case '#':
-				case '!':
-				case '=':
-				case ':':
-				case ' ' when escapeSpaces || index == 0:
-					await writer.WriteAsync('\\');
-					await writer.WriteAsync(c);
-					break;
-				case var _ when c > 31 && c < 127:
-					await writer.WriteAsync(c);
-					break;
-				case '\t':
-					await writer.WriteAsync("\\t");
-					break;
-				case '\n':
-					await writer.WriteAsync("\\n");
-					break;
-				case '\r':
-					await writer.WriteAsync("\\r");
-					break;
-				case '\f':
-					await writer.WriteAsync("\\f");
-					break;
-				default:
-					await writer.WriteAsync("\\u");
-					await writer.WriteAsync(((int) c).ToString("X4"));
-					break;
+		await targetWriter.WriteComment(comment, cancellationToken);
+		
+		var remainingOverriddenPropertyKeys = new HashSet<string>(overriddenProperties.Keys);
+		
+		await foreach ((string key, string value) in sourceReader.ReadProperties(cancellationToken)) {
+			if (remainingOverriddenPropertyKeys.Remove(key)) {
+				await targetWriter.WriteProperty(key, overriddenProperties[key], cancellationToken);
 			}
+			else {
+				await targetWriter.WriteProperty(key, value, cancellationToken);
+			}
+		}
+		
+		foreach (string key in remainingOverriddenPropertyKeys) {
+			await targetWriter.WriteProperty(key, overriddenProperties[key], cancellationToken);
 		}
 	}
 }

Agent/Phantom.Agent.Minecraft/Java/JavaPropertiesStream.cs

@@ -0,0 +1,284 @@
+using System.Buffers;
+using System.Globalization;
+using System.Runtime.CompilerServices;
+using System.Text;
+using Phantom.Utils.Collections;
+
+namespace Phantom.Agent.Minecraft.Java;
+
+static class JavaPropertiesStream {
+	internal static readonly Encoding Encoding = Encoding.GetEncoding("ISO-8859-1");
+	
+	private static FileStreamOptions CreateFileStreamOptions(FileMode mode, FileAccess access) {
+		return new FileStreamOptions {
+			Mode = mode,
+			Access = access,
+			Share = FileShare.Read,
+			Options = FileOptions.SequentialScan,
+		};
+	}
+	
+	internal sealed class Reader : IDisposable {
+		private static readonly SearchValues<char> LineStartWhitespace = SearchValues.Create(' ', '\t', '\f');
+		private static readonly SearchValues<char> KeyValueDelimiter = SearchValues.Create('=', ':', ' ', '\t', '\f');
+		private static readonly SearchValues<char> Backslash = SearchValues.Create('\\');
+		
+		private readonly StreamReader reader;
+		
+		public Reader(Stream stream) {
+			this.reader = new StreamReader(stream, Encoding, leaveOpen: false);
+		}
+		
+		public Reader(string path) {
+			this.reader = new StreamReader(path, Encoding, detectEncodingFromByteOrderMarks: false, CreateFileStreamOptions(FileMode.Open, FileAccess.Read));
+		}
+		
+		public async IAsyncEnumerable<KeyValuePair<string, string>> ReadProperties([EnumeratorCancellation] CancellationToken cancellationToken) {
+			await foreach (string line in ReadLogicalLines(cancellationToken)) {
+				yield return ParseLine(line.AsSpan());
+			}
+		}
+		
+		private async IAsyncEnumerable<string> ReadLogicalLines([EnumeratorCancellation] CancellationToken cancellationToken) {
+			StringBuilder nextLogicalLine = new StringBuilder();
+			
+			while (await reader.ReadLineAsync(cancellationToken) is {} line) {
+				var span = line.AsSpan();
+				int startIndex = span.IndexOfAnyExcept(LineStartWhitespace);
+				if (startIndex == -1) {
+					continue;
+				}
+				
+				if (nextLogicalLine.Length == 0 && (span[0] == '#' || span[0] == '!')) {
+					continue;
+				}
+				
+				span = span[startIndex..];
+				
+				if (IsEndEscaped(span)) {
+					nextLogicalLine.Append(span[..^1]);
+					nextLogicalLine.Append('\n');
+				}
+				else {
+					nextLogicalLine.Append(span);
+					yield return nextLogicalLine.ToString();
+					nextLogicalLine.Clear();
+				}
+			}
+			
+			if (nextLogicalLine.Length > 0) {
+				yield return nextLogicalLine.ToString(startIndex: 0, nextLogicalLine.Length - 1); // Remove trailing new line.
+			}
+		}
+		
+		private static KeyValuePair<string, string> ParseLine(ReadOnlySpan<char> line) {
+			int delimiterIndex = -1;
+			
+			foreach (int candidateIndex in line.IndicesOf(KeyValueDelimiter)) {
+				if (candidateIndex == 0 || !IsEndEscaped(line[..candidateIndex])) {
+					delimiterIndex = candidateIndex;
+					break;
+				}
+			}
+			
+			if (delimiterIndex == -1) {
+				return new KeyValuePair<string, string>(line.ToString(), string.Empty);
+			}
+			
+			string key = ReadPropertyComponent(line[..delimiterIndex]);
+			
+			line = line[(delimiterIndex + 1)..];
+			int valueStartIndex = line.IndexOfAnyExcept(KeyValueDelimiter);
+			string value = valueStartIndex == -1 ? string.Empty : ReadPropertyComponent(line[valueStartIndex..]);
+			
+			return new KeyValuePair<string, string>(key, value);
+		}
+		
+		private static string ReadPropertyComponent(ReadOnlySpan<char> component) {
+			StringBuilder builder = new StringBuilder();
+			int nextStartIndex = 0;
+			
+			foreach (int backslashIndex in component.IndicesOf(Backslash)) {
+				if (backslashIndex == component.Length - 1) {
+					break;
+				}
+				
+				if (backslashIndex < nextStartIndex) {
+					continue;
+				}
+				
+				builder.Append(component[nextStartIndex..backslashIndex]);
+				
+				int escapedIndex = backslashIndex + 1;
+				int escapedLength = 1;
+				
+				char c = component[escapedIndex];
+				switch (c) {
+					case 't':
+						builder.Append('\t');
+						break;
+					
+					case 'n':
+						builder.Append('\n');
+						break;
+					
+					case 'r':
+						builder.Append('\r');
+						break;
+					
+					case 'f':
+						builder.Append('\f');
+						break;
+					
+					case 'u':
+						escapedLength += 4;
+						
+						int hexRangeStart = escapedIndex + 1;
+						int hexRangeEnd = hexRangeStart + 4;
+						
+						if (hexRangeEnd - 1 < component.Length) {
+							var hexString = component[hexRangeStart..hexRangeEnd];
+							int hexValue = int.Parse(hexString, NumberStyles.HexNumber);
+							builder.Append((char) hexValue);
+						}
+						else {
+							throw new FormatException("Malformed \\uxxxx encoding.");
+						}
+						
+						break;
+					
+					default:
+						builder.Append(c);
+						break;
+				}
+				
+				nextStartIndex = escapedIndex + escapedLength;
+			}
+			
+			builder.Append(component[nextStartIndex..]);
+			return builder.ToString();
+		}
+		
+		private static bool IsEndEscaped(ReadOnlySpan<char> span) {
+			if (span.EndsWith('\\')) {
+				int trailingBackslashCount = span.Length - span.TrimEnd('\\').Length;
+				return trailingBackslashCount % 2 == 1;
+			}
+			else {
+				return false;
+			}
+		}
+		
+		public void Dispose() {
+			reader.Dispose();
+		}
+	}
+	
+	internal sealed class Writer : IAsyncDisposable {
+		private const string CommentStart = "# ";
+		
+		private readonly StreamWriter writer;
+		private readonly Memory<char> oneCharBuffer = new char[1];
+		
+		public Writer(Stream stream) {
+			this.writer = new StreamWriter(stream, Encoding, leaveOpen: false);
+		}
+		
+		public Writer(string path) {
+			this.writer = new StreamWriter(path, Encoding, CreateFileStreamOptions(FileMode.Create, FileAccess.Write));
+		}
+		
+		public async Task WriteComment(string comment, CancellationToken cancellationToken) {
+			await Write(CommentStart, cancellationToken);
+			
+			for (int index = 0; index < comment.Length; index++) {
+				char c = comment[index];
+				switch (c) {
+					case var _ when c > 31 && c < 127:
+						await Write(c, cancellationToken);
+						break;
+					
+					case '\n':
+					case '\r':
+						await Write(c: '\n', cancellationToken);
+						await Write(CommentStart, cancellationToken);
+						
+						if (index < comment.Length - 1 && comment[index + 1] == '\n') {
+							index++;
+						}
+						
+						break;
+					
+					default:
+						await Write("\\u", cancellationToken);
+						await Write(((int) c).ToString("X4"), cancellationToken);
+						break;
+				}
+			}
+			
+			await Write(c: '\n', cancellationToken);
+		}
+		
+		public async Task WriteProperty(string key, string value, CancellationToken cancellationToken) {
+			await WritePropertyComponent(key, escapeSpaces: true, cancellationToken);
+			await Write(c: '=', cancellationToken);
+			await WritePropertyComponent(value, escapeSpaces: false, cancellationToken);
+			await Write(c: '\n', cancellationToken);
+		}
+		
+		private async Task WritePropertyComponent(string component, bool escapeSpaces, CancellationToken cancellationToken) {
+			for (int index = 0; index < component.Length; index++) {
+				char c = component[index];
+				switch (c) {
+					case '\\':
+					case '#':
+					case '!':
+					case '=':
+					case ':':
+					case ' ' when escapeSpaces || index == 0:
+						await Write(c: '\\', cancellationToken);
+						await Write(c, cancellationToken);
+						break;
+					
+					case var _ when c > 31 && c < 127:
+						await Write(c, cancellationToken);
+						break;
+					
+					case '\t':
+						await Write("\\t", cancellationToken);
+						break;
+					
+					case '\n':
+						await Write("\\n", cancellationToken);
+						break;
+					
+					case '\r':
+						await Write("\\r", cancellationToken);
+						break;
+					
+					case '\f':
+						await Write("\\f", cancellationToken);
+						break;
+					
+					default:
+						await Write("\\u", cancellationToken);
+						await Write(((int) c).ToString("X4"), cancellationToken);
+						break;
+				}
+			}
+		}
+		
+		private Task Write(char c, CancellationToken cancellationToken) {
+			oneCharBuffer.Span[0] = c;
+			return writer.WriteAsync(oneCharBuffer, cancellationToken);
+		}
+		
+		private Task Write(string value, CancellationToken cancellationToken) {
+			return writer.WriteAsync(value.AsMemory(), cancellationToken);
+		}
+		
+		public async ValueTask DisposeAsync() {
+			await writer.DisposeAsync();
+		}
+	}
+}

Agent/Phantom.Agent.Minecraft/Launcher/BaseLauncher.cs

@@ -43,7 +43,7 @@ public abstract class BaseLauncher : IServerLauncher {
 		
 		try {
 			await AcceptEula(instanceProperties);
-			await UpdateServerProperties(instanceProperties);
+			await UpdateServerProperties(instanceProperties, cancellationToken);
 		} catch (Exception e) {
 			logger.Error(e, "Caught exception while configuring the server.");
 			return new LaunchResult.CouldNotConfigureMinecraftServer();
@@ -108,9 +108,9 @@ public abstract class BaseLauncher : IServerLauncher {
 		await File.WriteAllLinesAsync(eulaFilePath, ["# EULA", "eula=true"], Encoding.UTF8);
 	}
 	
-	private static async Task UpdateServerProperties(InstanceProperties instanceProperties) {
+	private static async Task UpdateServerProperties(InstanceProperties instanceProperties, CancellationToken cancellationToken) {
 		var serverPropertiesEditor = new JavaPropertiesFileEditor();
 		instanceProperties.ServerProperties.SetTo(serverPropertiesEditor);
-		await serverPropertiesEditor.EditOrCreate(Path.Combine(instanceProperties.InstanceFolder, "server.properties"));
+		await serverPropertiesEditor.EditOrCreate(Path.Combine(instanceProperties.InstanceFolder, "server.properties"), comment: "server.properties", cancellationToken);
 	}
 }

Agent/Phantom.Agent.Minecraft/Phantom.Agent.Minecraft.csproj

@@ -6,7 +6,7 @@
   </PropertyGroup>
   
   <ItemGroup>
-    <PackageReference Include="Kajabity.Tools.Java" />
+    <InternalsVisibleTo Include="Phantom.Agent.Minecraft.Tests" />
   </ItemGroup>
   
   <ItemGroup>

Controller/Phantom.Controller.Services/Agents/AgentActor.cs

@@ -26,7 +26,7 @@ using Serilog;
 
 namespace Phantom.Controller.Services.Agents;
 
-sealed class AgentActor : ReceiveActor<AgentActor.ICommand> {
+sealed class AgentActor : ReceiveActor<AgentActor.ICommand>, IWithTimers {
 	private static readonly ILogger Logger = PhantomLogger.Create<AgentActor>();
 	
 	private static readonly TimeSpan DisconnectionRecheckInterval = TimeSpan.FromSeconds(5);
@@ -38,6 +38,8 @@ sealed class AgentActor : ReceiveActor<AgentActor.ICommand> {
 		return Props<ICommand>.Create(() => new AgentActor(init), new ActorConfiguration { SupervisorStrategy = SupervisorStrategies.Resume, MailboxType = UnboundedJumpAheadMailbox.Name });
 	}
 	
+	public ITimerScheduler Timers { get; set; } = null!;
+	
 	private readonly ControllerState controllerState;
 	private readonly MinecraftVersions minecraftVersions;
 	private readonly IDbContextProvider dbProvider;
@@ -110,7 +112,7 @@ sealed class AgentActor : ReceiveActor<AgentActor.ICommand> {
 	protected override void PreStart() {
 		Self.Tell(new InitializeCommand());
 		
-		Context.System.Scheduler.ScheduleTellRepeatedly(DisconnectionRecheckInterval, DisconnectionRecheckInterval, Self, new RefreshConnectionStatusCommand(), Self);
+		Timers.StartPeriodicTimer("RefreshConnectionStatus", new RefreshConnectionStatusCommand(), DisconnectionRecheckInterval, Self);
 	}
 	
 	private ActorRef<InstanceActor.ICommand> CreateNewInstance(Instance instance) {

Controller/Phantom.Controller.Services/Agents/AgentDatabaseStorageActor.cs

@@ -1,4 +1,5 @@
-using Phantom.Common.Data.Web.Agent;
+using Akka.Actor;
+using Phantom.Common.Data.Web.Agent;
 using Phantom.Controller.Database;
 using Phantom.Utils.Actor;
 using Phantom.Utils.Logging;
@@ -6,7 +7,7 @@ using Serilog;
 
 namespace Phantom.Controller.Services.Agents;
 
-sealed class AgentDatabaseStorageActor : ReceiveActor<AgentDatabaseStorageActor.ICommand> {
+sealed class AgentDatabaseStorageActor : ReceiveActor<AgentDatabaseStorageActor.ICommand>, IWithTimers {
 	private static readonly ILogger Logger = PhantomLogger.Create<AgentDatabaseStorageActor>();
 	
 	public readonly record struct Init(Guid AgentGuid, IDbContextProvider DbProvider, CancellationToken CancellationToken);
@@ -15,6 +16,8 @@ sealed class AgentDatabaseStorageActor : ReceiveActor<AgentDatabaseStorageActor.
 		return Props<ICommand>.Create(() => new AgentDatabaseStorageActor(init), new ActorConfiguration { SupervisorStrategy = SupervisorStrategies.Resume });
 	}
 	
+	public ITimerScheduler Timers { get; set; } = null!;
+	
 	private readonly Guid agentGuid;
 	private readonly IDbContextProvider dbProvider;
 	private readonly CancellationToken cancellationToken;
@@ -74,7 +77,7 @@ sealed class AgentDatabaseStorageActor : ReceiveActor<AgentDatabaseStorageActor.
 	private void ScheduleFlush(TimeSpan delay) {
 		if (!hasScheduledFlush) {
 			hasScheduledFlush = true;
-			Context.System.Scheduler.ScheduleTellOnce(delay, Self, new FlushChangesCommand(), Self);
+			Timers.StartSingleTimer("FlushChanges", new FlushChangesCommand(), delay, Self);
 		}
 	}
 }

Controller/Phantom.Controller.Services/Events/EventLogDatabaseStorageActor.cs

@@ -1,4 +1,5 @@
-using Phantom.Common.Data.Web.EventLog;
+using Akka.Actor;
+using Phantom.Common.Data.Web.EventLog;
 using Phantom.Controller.Database;
 using Phantom.Controller.Database.Repositories;
 using Phantom.Utils.Actor;
@@ -7,7 +8,7 @@ using Serilog;
 
 namespace Phantom.Controller.Services.Events;
 
-sealed class EventLogDatabaseStorageActor : ReceiveActor<EventLogDatabaseStorageActor.ICommand> {
+sealed class EventLogDatabaseStorageActor : ReceiveActor<EventLogDatabaseStorageActor.ICommand>, IWithTimers {
 	private static readonly ILogger Logger = PhantomLogger.Create<EventLogDatabaseStorageActor>();
 	
 	public readonly record struct Init(IDbContextProvider DbProvider, CancellationToken CancellationToken);
@@ -16,6 +17,8 @@ sealed class EventLogDatabaseStorageActor : ReceiveActor<EventLogDatabaseStorage
 		return Props<ICommand>.Create(() => new EventLogDatabaseStorageActor(init), new ActorConfiguration { SupervisorStrategy = SupervisorStrategies.Resume });
 	}
 	
+	public ITimerScheduler Timers { get; set; } = null!;
+	
 	private readonly IDbContextProvider dbProvider;
 	private readonly CancellationToken cancellationToken;
 	
@@ -71,7 +74,7 @@ sealed class EventLogDatabaseStorageActor : ReceiveActor<EventLogDatabaseStorage
 	private void ScheduleFlush(TimeSpan delay) {
 		if (!hasScheduledFlush) {
 			hasScheduledFlush = true;
-			Context.System.Scheduler.ScheduleTellOnce(delay, Self, new FlushChangesCommand(), Self);
+			Timers.StartSingleTimer("FlushChanges", new FlushChangesCommand(), delay, Self);
 		}
 	}
 }

Packages.props

@@ -1,23 +1,19 @@
 <Project>
   
   <ItemGroup>
-    <PackageReference Update="Microsoft.AspNetCore.Components.Authorization" Version="8.0.0" />
-    <PackageReference Update="Microsoft.AspNetCore.Components.Web"           Version="8.0.0" />
+    <PackageReference Update="Microsoft.AspNetCore.Components.Authorization" Version="9.0.9" />
+    <PackageReference Update="Microsoft.AspNetCore.Components.Web"           Version="9.0.9" />
   </ItemGroup>
   
   <ItemGroup>
-    <PackageReference Update="Microsoft.EntityFrameworkCore.Relational" Version="8.0.0" />
-    <PackageReference Update="Microsoft.EntityFrameworkCore.Tools"      Version="8.0.0" />
-    <PackageReference Update="Npgsql.EntityFrameworkCore.PostgreSQL"    Version="8.0.0" />
-    <PackageReference Update="System.Linq.Async"                        Version="6.0.1" />
+    <PackageReference Update="Microsoft.EntityFrameworkCore.Relational" Version="9.0.9" />
+    <PackageReference Update="Microsoft.EntityFrameworkCore.Tools"      Version="9.0.9" />
+    <PackageReference Update="Npgsql.EntityFrameworkCore.PostgreSQL"    Version="9.0.4" />
+    <PackageReference Update="System.Linq.Async"                        Version="6.0.3" />
   </ItemGroup>
   
   <ItemGroup>
-    <PackageReference Update="Kajabity.Tools.Java" Version="0.3.8607.38728" />
-  </ItemGroup>
-  
-  <ItemGroup>
-    <PackageReference Update="Akka"                       Version="1.5.17.1" />
+    <PackageReference Update="Akka" Version="1.5.51" />
   </ItemGroup>
   
   <ItemGroup>
@@ -26,10 +22,10 @@
   </ItemGroup>
   
   <ItemGroup>
-    <PackageReference Update="Serilog"               Version="3.1.1" />
-    <PackageReference Update="Serilog.AspNetCore"    Version="8.0.0" />
-    <PackageReference Update="Serilog.Sinks.Async"   Version="1.5.0" />
-    <PackageReference Update="Serilog.Sinks.Console" Version="5.0.1" />
+    <PackageReference Update="Serilog"               Version="4.3.0" />
+    <PackageReference Update="Serilog.AspNetCore"    Version="9.0.0" />
+    <PackageReference Update="Serilog.Sinks.Async"   Version="2.1.0" />
+    <PackageReference Update="Serilog.Sinks.Console" Version="6.0.0" />
   </ItemGroup>
   
   <ItemGroup>

PhantomPanel.sln

@@ -2,6 +2,8 @@
 Microsoft Visual Studio Solution File, Format Version 12.00
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Agent", "Agent", "{F5878792-64C8-4ECF-A075-66341FF97127}"
 EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Agent.Tests", "Agent.Tests", "{94C1E464-3F91-49EA-99FF-3A3082C54CE8}"
+EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Common", "Common", "{01CB1A81-8950-471C-BFDF-F135FDDB2C18}"
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Common.Tests", "Common.Tests", "{D781E00D-8563-4102-A0CD-477A679193B5}"
@@ -18,6 +20,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Phantom.Agent", "Agent\Phan
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Phantom.Agent.Minecraft", "Agent\Phantom.Agent.Minecraft\Phantom.Agent.Minecraft.csproj", "{9FE000D0-91AC-4CB4-8956-91CCC0270015}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Phantom.Agent.Minecraft.Tests", "Agent\Phantom.Agent.Minecraft.Tests\Phantom.Agent.Minecraft.Tests.csproj", "{065FFFA0-DFF4-43DB-AB3D-B92EE9848DDB}"
+EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Phantom.Agent.Services", "Agent\Phantom.Agent.Services\Phantom.Agent.Services.csproj", "{AEE8B77E-AB07-423F-9981-8CD829ACB834}"
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Phantom.Common.Data", "Common\Phantom.Common.Data\Phantom.Common.Data.csproj", "{6C3DB1E5-F695-4D70-8F3A-78C2957274BE}"
@@ -74,6 +78,10 @@ Global
 		{9FE000D0-91AC-4CB4-8956-91CCC0270015}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{9FE000D0-91AC-4CB4-8956-91CCC0270015}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{9FE000D0-91AC-4CB4-8956-91CCC0270015}.Release|Any CPU.Build.0 = Release|Any CPU
+		{065FFFA0-DFF4-43DB-AB3D-B92EE9848DDB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{065FFFA0-DFF4-43DB-AB3D-B92EE9848DDB}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{065FFFA0-DFF4-43DB-AB3D-B92EE9848DDB}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{065FFFA0-DFF4-43DB-AB3D-B92EE9848DDB}.Release|Any CPU.Build.0 = Release|Any CPU
 		{AEE8B77E-AB07-423F-9981-8CD829ACB834}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{AEE8B77E-AB07-423F-9981-8CD829ACB834}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{AEE8B77E-AB07-423F-9981-8CD829ACB834}.Release|Any CPU.ActiveCfg = Release|Any CPU
@@ -158,6 +166,7 @@ Global
 	GlobalSection(NestedProjects) = preSolution
 		{418BE1BF-9F63-4B46-B4E4-DF64C3B3DDA7} = {F5878792-64C8-4ECF-A075-66341FF97127}
 		{9FE000D0-91AC-4CB4-8956-91CCC0270015} = {F5878792-64C8-4ECF-A075-66341FF97127}
+		{065FFFA0-DFF4-43DB-AB3D-B92EE9848DDB} = {94C1E464-3F91-49EA-99FF-3A3082C54CE8}
 		{AEE8B77E-AB07-423F-9981-8CD829ACB834} = {F5878792-64C8-4ECF-A075-66341FF97127}
 		{6C3DB1E5-F695-4D70-8F3A-78C2957274BE} = {01CB1A81-8950-471C-BFDF-F135FDDB2C18}
 		{95B55357-F8F0-48C2-A1C2-5EA997651783} = {01CB1A81-8950-471C-BFDF-F135FDDB2C18}

Utils/Phantom.Utils.Tests/Collections/SpanIndexEnumeratorTests.cs

@@ -0,0 +1,52 @@
+using System.Buffers;
+using System.Diagnostics.CodeAnalysis;
+using NUnit.Framework;
+using Phantom.Utils.Collections;
+
+namespace Phantom.Utils.Tests.Collections;
+
+[TestFixture]
+[SuppressMessage("Performance", "CA1861")]
+public sealed class SpanIndexEnumeratorTests {
+	private static SearchValues<char> Search => SearchValues.Create(' ', '-');
+	
+	private static List<int> Indices(string str) {
+		List<int> indices = [];
+		
+		foreach (int index in str.AsSpan().IndicesOf(Search)) {
+			indices.Add(index);
+		}
+		
+		return indices;
+	}
+	
+	[Test]
+	public void Empty() {
+		Assert.That(Indices(""), Is.EquivalentTo(Array.Empty<int>()));
+	}
+	
+	[Test]
+	public void OnlyFirstIndex() {
+		Assert.That(Indices(" "), Is.EquivalentTo(new[] { 0 }));
+	}
+	
+	[Test]
+	public void OnlyMiddleIndex() {
+		Assert.That(Indices("ab cd"), Is.EquivalentTo(new[] { 2 }));
+	}
+	
+	[Test]
+	public void OnlyLastIndex() {
+		Assert.That(Indices("abc "), Is.EquivalentTo(new[] { 3 }));
+	}
+	
+	[Test]
+	public void FirstAndLastIndex() {
+		Assert.That(Indices(" abc-"), Is.EquivalentTo(new[] { 0, 4 }));
+	}
+	
+	[Test]
+	public void AllIndices() {
+		Assert.That(Indices("-  -  -"), Is.EquivalentTo(new[] { 0, 1, 2, 3, 4, 5, 6 }));
+	}
+}

Utils/Phantom.Utils/Collections/SpanIndexEnumerator.cs

@@ -0,0 +1,37 @@
+using System.Buffers;
+using System.Collections;
+
+namespace Phantom.Utils.Collections;
+
+public ref struct SpanIndexEnumerator<T>(ReadOnlySpan<T> span, SearchValues<T> searchValues) : IEnumerator<int> where T : IEquatable<T> {
+	private readonly ReadOnlySpan<T> span = span;
+	
+	public int Current { get; private set; } = -1;
+	
+	readonly object IEnumerator.Current => Current;
+	
+	public readonly SpanIndexEnumerator<T> GetEnumerator() => this;
+	
+	public bool MoveNext() {
+		int startIndex = Current + 1;
+		int relativeIndex = span[startIndex..].IndexOfAny(searchValues);
+		if (relativeIndex == -1) {
+			return false;
+		}
+		
+		Current = startIndex + relativeIndex;
+		return true;
+	}
+	
+	public void Reset() {
+		Current = -1;
+	}
+	
+	public void Dispose() {}
+}
+
+public static class SpanIndexEnumeratorExtensions {
+	public static SpanIndexEnumerator<T> IndicesOf<T>(this ReadOnlySpan<T> span, SearchValues<T> searchValues) where T : IEquatable<T> {
+		return new SpanIndexEnumerator<T>(span, searchValues);
+	}
+}

Web/Phantom.Web/WebLauncher.cs

@@ -53,10 +53,10 @@ static class WebLauncher {
 			application.UseExceptionHandler("/_Error");
 		}
 		
-		application.UseStaticFiles();
 		application.UseRouting();
 		application.UsePhantomServices();
 		
+		application.MapStaticAssets();
 		application.MapControllers();
 		application.MapBlazorHub();
 		application.MapFallbackToPage("/_Host");