Update MemoryPack to 1.21.4

Agent/Phantom.Agent/Program.cs

@@ -65,7 +65,7 @@ try {
 		MaxConcurrentlyHandledMessages: 50
 	);
 	
-	using var rpcClient = await RpcClient<IMessageToController, IMessageToAgent>.Connect("Controller", rpcClientConnectionParameters, AgentMessageRegistries.Definitions, shutdownCancellationToken);
+	using var rpcClient = await RpcClient<IMessageToController, IMessageToAgent>.Connect("Controller", rpcClientConnectionParameters, AgentMessageRegistries.Registries, shutdownCancellationToken);
 	if (rpcClient == null) {
 		PhantomLogger.Root.Fatal("Could not connect to Phantom Controller, shutting down.");
 		return 1;

Common/Phantom.Common.Data.Web/Users/AddUserError.cs

@@ -1,19 +1,16 @@
 using System.Collections.Immutable;
 using MemoryPack;
-using Phantom.Common.Data.Web.Users.AddUserErrors;
 
-namespace Phantom.Common.Data.Web.Users {
+namespace Phantom.Common.Data.Web.Users;
-	[MemoryPackable]
-	[MemoryPackUnion(tag: 0, typeof(NameIsInvalid))]
-	[MemoryPackUnion(tag: 1, typeof(PasswordIsInvalid))]
-	[MemoryPackUnion(tag: 2, typeof(NameAlreadyExists))]
-	[MemoryPackUnion(tag: 3, typeof(UnknownError))]
-	public abstract partial record AddUserError {
-		internal AddUserError() {}
-	}
-}
 
-namespace Phantom.Common.Data.Web.Users.AddUserErrors {
+[MemoryPackable]
+[MemoryPackUnion(tag: 0, typeof(NameIsInvalid))]
+[MemoryPackUnion(tag: 1, typeof(PasswordIsInvalid))]
+[MemoryPackUnion(tag: 2, typeof(NameAlreadyExists))]
+[MemoryPackUnion(tag: 3, typeof(UnknownError))]
+public abstract partial record AddUserError {
+	private AddUserError() {}
+	
 	[MemoryPackable(GenerateType.VersionTolerant)]
 	public sealed partial record NameIsInvalid([property: MemoryPackOrder(0)] UsernameRequirementViolation Violation) : AddUserError;
 	

Common/Phantom.Common.Data.Web/Users/CreateOrUpdateAdministratorUserResult.cs

@@ -1,19 +1,16 @@
 using MemoryPack;
-using Phantom.Common.Data.Web.Users.CreateOrUpdateAdministratorUserResults;
 
-namespace Phantom.Common.Data.Web.Users {
+namespace Phantom.Common.Data.Web.Users;
-	[MemoryPackable]
-	[MemoryPackUnion(tag: 0, typeof(Success))]
-	[MemoryPackUnion(tag: 1, typeof(CreationFailed))]
-	[MemoryPackUnion(tag: 2, typeof(UpdatingFailed))]
-	[MemoryPackUnion(tag: 3, typeof(AddingToRoleFailed))]
-	[MemoryPackUnion(tag: 4, typeof(UnknownError))]
-	public abstract partial record CreateOrUpdateAdministratorUserResult {
-		internal CreateOrUpdateAdministratorUserResult() {}
-	}
-}
 
-namespace Phantom.Common.Data.Web.Users.CreateOrUpdateAdministratorUserResults {
+[MemoryPackable]
+[MemoryPackUnion(tag: 0, typeof(Success))]
+[MemoryPackUnion(tag: 1, typeof(CreationFailed))]
+[MemoryPackUnion(tag: 2, typeof(UpdatingFailed))]
+[MemoryPackUnion(tag: 3, typeof(AddingToRoleFailed))]
+[MemoryPackUnion(tag: 4, typeof(UnknownError))]
+public abstract partial record CreateOrUpdateAdministratorUserResult {
+	private CreateOrUpdateAdministratorUserResult() {}
+	
 	[MemoryPackable(GenerateType.VersionTolerant)]
 	public sealed partial record Success([property: MemoryPackOrder(0)] UserInfo User) : CreateOrUpdateAdministratorUserResult;
 	

Common/Phantom.Common.Data.Web/Users/CreateUserResult.cs

@@ -1,17 +1,14 @@
 using MemoryPack;
-using Phantom.Common.Data.Web.Users.CreateUserResults;
 
-namespace Phantom.Common.Data.Web.Users {
+namespace Phantom.Common.Data.Web.Users;
-	[MemoryPackable]
-	[MemoryPackUnion(tag: 0, typeof(Success))]
-	[MemoryPackUnion(tag: 1, typeof(CreationFailed))]
-	[MemoryPackUnion(tag: 2, typeof(UnknownError))]
-	public abstract partial record CreateUserResult {
-		internal CreateUserResult() {}
-	}
-}
 
-namespace Phantom.Common.Data.Web.Users.CreateUserResults {
+[MemoryPackable]
+[MemoryPackUnion(tag: 0, typeof(Success))]
+[MemoryPackUnion(tag: 1, typeof(CreationFailed))]
+[MemoryPackUnion(tag: 2, typeof(UnknownError))]
+public abstract partial record CreateUserResult {
+	private CreateUserResult() {}
+	
 	[MemoryPackable(GenerateType.VersionTolerant)]
 	public sealed partial record Success([property: MemoryPackOrder(0)] UserInfo User) : CreateUserResult;
 	

Common/Phantom.Common.Data.Web/Users/PasswordRequirementViolation.cs

@@ -1,18 +1,15 @@
 using MemoryPack;
-using Phantom.Common.Data.Web.Users.PasswordRequirementViolations;
 
-namespace Phantom.Common.Data.Web.Users {
+namespace Phantom.Common.Data.Web.Users;
-	[MemoryPackable]
-	[MemoryPackUnion(tag: 0, typeof(TooShort))]
-	[MemoryPackUnion(tag: 1, typeof(MustContainLowercaseLetter))]
-	[MemoryPackUnion(tag: 2, typeof(MustContainUppercaseLetter))]
-	[MemoryPackUnion(tag: 3, typeof(MustContainDigit))]
-	public abstract partial record PasswordRequirementViolation {
-		internal PasswordRequirementViolation() {}
-	}
-}
 
-namespace Phantom.Common.Data.Web.Users.PasswordRequirementViolations {
+[MemoryPackable]
+[MemoryPackUnion(tag: 0, typeof(TooShort))]
+[MemoryPackUnion(tag: 1, typeof(MustContainLowercaseLetter))]
+[MemoryPackUnion(tag: 2, typeof(MustContainUppercaseLetter))]
+[MemoryPackUnion(tag: 3, typeof(MustContainDigit))]
+public abstract partial record PasswordRequirementViolation {
+	private PasswordRequirementViolation() {}
+	
 	[MemoryPackable(GenerateType.VersionTolerant)]
 	public sealed partial record TooShort([property: MemoryPackOrder(0)] int MinimumLength) : PasswordRequirementViolation;
 	

Common/Phantom.Common.Data.Web/Users/SetUserPasswordError.cs

@@ -1,18 +1,15 @@
 using System.Collections.Immutable;
 using MemoryPack;
-using Phantom.Common.Data.Web.Users.SetUserPasswordErrors;
 
-namespace Phantom.Common.Data.Web.Users {
+namespace Phantom.Common.Data.Web.Users;
-	[MemoryPackable]
-	[MemoryPackUnion(tag: 0, typeof(UserNotFound))]
-	[MemoryPackUnion(tag: 1, typeof(PasswordIsInvalid))]
-	[MemoryPackUnion(tag: 2, typeof(UnknownError))]
-	public abstract partial record SetUserPasswordError {
-		internal SetUserPasswordError() {}
-	}
-}
 
-namespace Phantom.Common.Data.Web.Users.SetUserPasswordErrors {
+[MemoryPackable]
+[MemoryPackUnion(tag: 0, typeof(UserNotFound))]
+[MemoryPackUnion(tag: 1, typeof(PasswordIsInvalid))]
+[MemoryPackUnion(tag: 2, typeof(UnknownError))]
+public abstract partial record SetUserPasswordError {
+	private SetUserPasswordError() {}
+	
 	[MemoryPackable(GenerateType.VersionTolerant)]
 	public sealed partial record UserNotFound : SetUserPasswordError;
 	

Common/Phantom.Common.Data.Web/Users/UserInstanceActionFailure.cs

@@ -4,22 +4,22 @@ using Phantom.Common.Data.Replies;
 namespace Phantom.Common.Data.Web.Users;
 
 [MemoryPackable]
-[MemoryPackUnion(tag: 0, typeof(OfUserActionFailure))]
+[MemoryPackUnion(tag: 0, typeof(User))]
-[MemoryPackUnion(tag: 1, typeof(OfInstanceActionFailure))]
+[MemoryPackUnion(tag: 1, typeof(Instance))]
 public abstract partial record UserInstanceActionFailure {
-	internal UserInstanceActionFailure() {}
+	private UserInstanceActionFailure() {}
+	
+	[MemoryPackable(GenerateType.VersionTolerant)]
+	public sealed partial record User([property: MemoryPackOrder(0)] UserActionFailure Failure) : UserInstanceActionFailure;
+	
+	[MemoryPackable(GenerateType.VersionTolerant)]
+	public sealed partial record Instance([property: MemoryPackOrder(0)] InstanceActionFailure Failure) : UserInstanceActionFailure;
 	
 	public static implicit operator UserInstanceActionFailure(UserActionFailure failure) {
-		return new OfUserActionFailure(failure);
+		return new User(failure);
 	}
 	
 	public static implicit operator UserInstanceActionFailure(InstanceActionFailure failure) {
-		return new OfInstanceActionFailure(failure);
+		return new Instance(failure);
 	}
 }
-
-[MemoryPackable(GenerateType.VersionTolerant)]
-public sealed partial record OfUserActionFailure([property: MemoryPackOrder(0)] UserActionFailure Failure) : UserInstanceActionFailure;
-
-[MemoryPackable(GenerateType.VersionTolerant)]
-public sealed partial record OfInstanceActionFailure([property: MemoryPackOrder(0)] InstanceActionFailure Failure) : UserInstanceActionFailure;

Common/Phantom.Common.Data.Web/Users/UsernameRequirementViolation.cs

@@ -1,16 +1,13 @@
 using MemoryPack;
-using Phantom.Common.Data.Web.Users.UsernameRequirementViolations;
 
-namespace Phantom.Common.Data.Web.Users {
+namespace Phantom.Common.Data.Web.Users;
-	[MemoryPackable]
-	[MemoryPackUnion(tag: 0, typeof(IsEmpty))]
-	[MemoryPackUnion(tag: 1, typeof(TooLong))]
-	public abstract partial record UsernameRequirementViolation {
-		internal UsernameRequirementViolation() {}
-	}
-}
 
-namespace Phantom.Common.Data.Web.Users.UsernameRequirementViolations {
+[MemoryPackable]
+[MemoryPackUnion(tag: 0, typeof(IsEmpty))]
+[MemoryPackUnion(tag: 1, typeof(TooLong))]
+public abstract partial record UsernameRequirementViolation {
+	private UsernameRequirementViolation() {}
+	
 	[MemoryPackable(GenerateType.VersionTolerant)]
 	public sealed partial record IsEmpty : UsernameRequirementViolation;
 	

Common/Phantom.Common.Data/Instance/InstancePlayerCounts.cs

@@ -3,7 +3,7 @@
 namespace Phantom.Common.Data.Instance;
 
 [MemoryPackable(GenerateType.VersionTolerant)]
-public readonly partial record struct InstancePlayerCounts(
+public sealed partial record InstancePlayerCounts(
 	[property: MemoryPackOrder(0)] int Online,
 	[property: MemoryPackOrder(1)] int Maximum
 );

Common/Phantom.Common.Data/Minecraft/MinecraftStopStrategy.cs

@@ -3,7 +3,7 @@
 namespace Phantom.Common.Data.Minecraft;
 
 [MemoryPackable(GenerateType.VersionTolerant)]
-public readonly partial record struct MinecraftStopStrategy(
+public sealed partial record MinecraftStopStrategy(
 	[property: MemoryPackOrder(0)] ushort Seconds
 ) {
 	public static MinecraftStopStrategy Instant => new (0);

Common/Phantom.Common.Data/PortRange.cs

@@ -3,7 +3,7 @@ using MemoryPack;
 
 namespace Phantom.Common.Data;
 
-[MemoryPackable(GenerateType.VersionTolerant)]
+[MemoryPackable]
 readonly partial record struct PortRange(
 	[property: MemoryPackOrder(0)] ushort FirstPort,
 	[property: MemoryPackOrder(1)] ushort LastPort

Common/Phantom.Common.Data/RamAllocationUnits.cs

@@ -6,7 +6,7 @@ namespace Phantom.Common.Data;
 /// <summary>
 /// Represents a number of RAM allocation units, using the conversion factor of 256 MB per unit. Supports allocations up to 16 TB minus 256 MB (65535 units).
 /// </summary>
-[MemoryPackable(GenerateType.VersionTolerant)]
+[MemoryPackable]
 [SuppressMessage("ReSharper", "MemberCanBePrivate.Global")]
 public readonly partial record struct RamAllocationUnits(
 	[property: MemoryPackOrder(0)] ushort RawValue

Common/Phantom.Common.Messages.Agent/AgentMessageRegistries.cs

@@ -10,23 +10,18 @@ public static class AgentMessageRegistries {
 	public static MessageRegistry<IMessageToAgent> ToAgent { get; } = new (nameof(ToAgent));
 	public static MessageRegistry<IMessageToController> ToController { get; } = new (nameof(ToController));
 	
-	public static IMessageDefinitions<IMessageToController, IMessageToAgent> Definitions { get; } = new MessageDefinitions();
+	public static MessageRegistries<IMessageToController, IMessageToAgent> Registries => new (ToAgent, ToController);
 	
 	static AgentMessageRegistries() {
-		ToAgent.Add<ConfigureInstanceMessage, Result<ConfigureInstanceResult, InstanceActionFailure>>(1);
+		ToAgent.Add<ConfigureInstanceMessage, Result<ConfigureInstanceResult, InstanceActionFailure>>();
-		ToAgent.Add<LaunchInstanceMessage, Result<LaunchInstanceResult, InstanceActionFailure>>(2);
+		ToAgent.Add<LaunchInstanceMessage, Result<LaunchInstanceResult, InstanceActionFailure>>();
-		ToAgent.Add<StopInstanceMessage, Result<StopInstanceResult, InstanceActionFailure>>(3);
+		ToAgent.Add<StopInstanceMessage, Result<StopInstanceResult, InstanceActionFailure>>();
-		ToAgent.Add<SendCommandToInstanceMessage, Result<SendCommandToInstanceResult, InstanceActionFailure>>(4);
+		ToAgent.Add<SendCommandToInstanceMessage, Result<SendCommandToInstanceResult, InstanceActionFailure>>();
 		
-		ToController.Add<ReportInstanceStatusMessage>(1);
+		ToController.Add<ReportInstanceStatusMessage>();
-		ToController.Add<InstanceOutputMessage>(2);
+		ToController.Add<InstanceOutputMessage>();
-		ToController.Add<ReportAgentStatusMessage>(3);
+		ToController.Add<ReportAgentStatusMessage>();
-		ToController.Add<ReportInstanceEventMessage>(4);
+		ToController.Add<ReportInstanceEventMessage>();
-		ToController.Add<ReportInstancePlayerCountsMessage>(5);
+		ToController.Add<ReportInstancePlayerCountsMessage>();
-	}
-	
-	private sealed class MessageDefinitions : IMessageDefinitions<IMessageToController, IMessageToAgent> {
-		public MessageRegistry<IMessageToAgent> ToClient => ToAgent;
-		public MessageRegistry<IMessageToController> ToServer => ToController;
 	}
 }

Common/Phantom.Common.Messages.Web/WebMessageRegistries.cs

@@ -17,36 +17,31 @@ public static class WebMessageRegistries {
 	public static MessageRegistry<IMessageToController> ToController { get; } = new (nameof(ToController));
 	public static MessageRegistry<IMessageToWeb> ToWeb { get; } = new (nameof(ToWeb));
 	
-	public static IMessageDefinitions<IMessageToController, IMessageToWeb> Definitions { get; } = new MessageDefinitions();
+	public static MessageRegistries<IMessageToController, IMessageToWeb> Registries => new (ToWeb, ToController);
 	
 	static WebMessageRegistries() {
-		ToController.Add<LogInMessage, Optional<LogInSuccess>>(1);
+		ToController.Add<LogInMessage, Optional<LogInSuccess>>();
-		ToController.Add<LogOutMessage>(2);
+		ToController.Add<LogOutMessage>();
-		ToController.Add<GetAuthenticatedUser, Optional<AuthenticatedUserInfo>>(3);
+		ToController.Add<GetAuthenticatedUser, Optional<AuthenticatedUserInfo>>();
-		ToController.Add<CreateOrUpdateAdministratorUserMessage, CreateOrUpdateAdministratorUserResult>(4);
+		ToController.Add<CreateOrUpdateAdministratorUserMessage, CreateOrUpdateAdministratorUserResult>();
-		ToController.Add<CreateUserMessage, Result<CreateUserResult, UserActionFailure>>(5);
+		ToController.Add<CreateUserMessage, Result<CreateUserResult, UserActionFailure>>();
-		ToController.Add<DeleteUserMessage, Result<DeleteUserResult, UserActionFailure>>(6);
+		ToController.Add<DeleteUserMessage, Result<DeleteUserResult, UserActionFailure>>();
-		ToController.Add<GetUsersMessage, ImmutableArray<UserInfo>>(7);
+		ToController.Add<GetUsersMessage, ImmutableArray<UserInfo>>();
-		ToController.Add<GetRolesMessage, ImmutableArray<RoleInfo>>(8);
+		ToController.Add<GetRolesMessage, ImmutableArray<RoleInfo>>();
-		ToController.Add<GetUserRolesMessage, ImmutableDictionary<Guid, ImmutableArray<Guid>>>(9);
+		ToController.Add<GetUserRolesMessage, ImmutableDictionary<Guid, ImmutableArray<Guid>>>();
-		ToController.Add<ChangeUserRolesMessage, Result<ChangeUserRolesResult, UserActionFailure>>(10);
+		ToController.Add<ChangeUserRolesMessage, Result<ChangeUserRolesResult, UserActionFailure>>();
-		ToController.Add<CreateOrUpdateInstanceMessage, Result<CreateOrUpdateInstanceResult, UserInstanceActionFailure>>(11);
+		ToController.Add<CreateOrUpdateInstanceMessage, Result<CreateOrUpdateInstanceResult, UserInstanceActionFailure>>();
-		ToController.Add<LaunchInstanceMessage, Result<LaunchInstanceResult, UserInstanceActionFailure>>(12);
+		ToController.Add<LaunchInstanceMessage, Result<LaunchInstanceResult, UserInstanceActionFailure>>();
-		ToController.Add<StopInstanceMessage, Result<StopInstanceResult, UserInstanceActionFailure>>(13);
+		ToController.Add<StopInstanceMessage, Result<StopInstanceResult, UserInstanceActionFailure>>();
-		ToController.Add<SendCommandToInstanceMessage, Result<SendCommandToInstanceResult, UserInstanceActionFailure>>(14);
+		ToController.Add<SendCommandToInstanceMessage, Result<SendCommandToInstanceResult, UserInstanceActionFailure>>();
-		ToController.Add<GetMinecraftVersionsMessage, ImmutableArray<MinecraftVersion>>(15);
+		ToController.Add<GetMinecraftVersionsMessage, ImmutableArray<MinecraftVersion>>();
-		ToController.Add<GetAgentJavaRuntimesMessage, ImmutableDictionary<Guid, ImmutableArray<TaggedJavaRuntime>>>(16);
+		ToController.Add<GetAgentJavaRuntimesMessage, ImmutableDictionary<Guid, ImmutableArray<TaggedJavaRuntime>>>();
-		ToController.Add<GetAuditLogMessage, Result<ImmutableArray<AuditLogItem>, UserActionFailure>>(17);
+		ToController.Add<GetAuditLogMessage, Result<ImmutableArray<AuditLogItem>, UserActionFailure>>();
-		ToController.Add<GetEventLogMessage, Result<ImmutableArray<EventLogItem>, UserActionFailure>>(18);
+		ToController.Add<GetEventLogMessage, Result<ImmutableArray<EventLogItem>, UserActionFailure>>();
 		
-		ToWeb.Add<RefreshAgentsMessage>(1);
+		ToWeb.Add<RefreshAgentsMessage>();
-		ToWeb.Add<RefreshInstancesMessage>(2);
+		ToWeb.Add<RefreshInstancesMessage>();
-		ToWeb.Add<InstanceOutputMessage>(3);
+		ToWeb.Add<InstanceOutputMessage>();
-		ToWeb.Add<RefreshUserSessionMessage>(4);
+		ToWeb.Add<RefreshUserSessionMessage>();
-	}
-	
-	private sealed class MessageDefinitions : IMessageDefinitions<IMessageToController, IMessageToWeb> {
-		public MessageRegistry<IMessageToWeb> ToClient => ToWeb;
-		public MessageRegistry<IMessageToController> ToServer => ToController;
 	}
 }

Controller/Phantom.Controller.Database/Repositories/UserRepository.cs

@@ -2,9 +2,6 @@
 using Microsoft.EntityFrameworkCore;
 using Phantom.Common.Data;
 using Phantom.Common.Data.Web.Users;
-using Phantom.Common.Data.Web.Users.AddUserErrors;
-using Phantom.Common.Data.Web.Users.PasswordRequirementViolations;
-using Phantom.Common.Data.Web.Users.UsernameRequirementViolations;
 using Phantom.Controller.Database.Entities;
 using Phantom.Utils.Collections;
 
@@ -16,10 +13,10 @@ public sealed class UserRepository {
 	
 	private static UsernameRequirementViolation? CheckUsernameRequirements(string username) {
 		if (string.IsNullOrWhiteSpace(username)) {
-			return new IsEmpty();
+			return new UsernameRequirementViolation.IsEmpty();
 		}
 		else if (username.Length > MaxUserNameLength) {
-			return new TooLong(MaxUserNameLength);
+			return new UsernameRequirementViolation.TooLong(MaxUserNameLength);
 		}
 		else {
 			return null;
@@ -30,19 +27,19 @@ public sealed class UserRepository {
 		var violations = ImmutableArray.CreateBuilder<PasswordRequirementViolation>();
 		
 		if (password.Length < MinimumPasswordLength) {
-			violations.Add(new TooShort(MinimumPasswordLength));
+			violations.Add(new PasswordRequirementViolation.TooShort(MinimumPasswordLength));
 		}
 		
 		if (!password.Any(char.IsLower)) {
-			violations.Add(new MustContainLowercaseLetter());
+			violations.Add(new PasswordRequirementViolation.MustContainLowercaseLetter());
 		}
 		
 		if (!password.Any(char.IsUpper)) {
-			violations.Add(new MustContainUppercaseLetter());
+			violations.Add(new PasswordRequirementViolation.MustContainUppercaseLetter());
 		}
 		
 		if (!password.Any(char.IsDigit)) {
-			violations.Add(new MustContainDigit());
+			violations.Add(new PasswordRequirementViolation.MustContainDigit());
 		}
 		
 		return violations.ToImmutable();
@@ -73,16 +70,16 @@ public sealed class UserRepository {
 	public async Task<Result<UserEntity, AddUserError>> CreateUser(string username, string password) {
 		var usernameRequirementViolation = CheckUsernameRequirements(username);
 		if (usernameRequirementViolation != null) {
-			return new NameIsInvalid(usernameRequirementViolation);
+			return new AddUserError.NameIsInvalid(usernameRequirementViolation);
 		}
 		
 		var passwordRequirementViolations = CheckPasswordRequirements(password);
 		if (!passwordRequirementViolations.IsEmpty) {
-			return new PasswordIsInvalid(passwordRequirementViolations);
+			return new AddUserError.PasswordIsInvalid(passwordRequirementViolations);
 		}
 		
 		if (await db.Ctx.Users.AnyAsync(user => user.Name == username)) {
-			return new NameAlreadyExists();
+			return new AddUserError.NameAlreadyExists();
 		}
 		
 		var user = new UserEntity(Guid.NewGuid(), username, UserPasswords.Hash(password));
@@ -95,7 +92,7 @@ public sealed class UserRepository {
 	public Result<SetUserPasswordError> SetUserPassword(UserEntity user, string password) {
 		var requirementViolations = CheckPasswordRequirements(password);
 		if (!requirementViolations.IsEmpty) {
-			return new Common.Data.Web.Users.SetUserPasswordErrors.PasswordIsInvalid(requirementViolations);
+			return new SetUserPasswordError.PasswordIsInvalid(requirementViolations);
 		}
 		
 		user.PasswordHash = UserPasswords.Hash(password);

Controller/Phantom.Controller.Services/Users/UserManager.cs

@@ -1,7 +1,6 @@
 using System.Collections.Immutable;
 using Phantom.Common.Data;
 using Phantom.Common.Data.Web.Users;
-using Phantom.Common.Data.Web.Users.CreateOrUpdateAdministratorUserResults;
 using Phantom.Controller.Database;
 using Phantom.Controller.Database.Entities;
 using Phantom.Controller.Database.Repositories;
@@ -57,12 +56,12 @@ sealed class UserManager {
 					wasCreated = true;
 				}
 				else {
-					return new CreationFailed(result.Error);
+					return new CreateOrUpdateAdministratorUserResult.CreationFailed(result.Error);
 				}
 			}
 			else {
 				if (userRepository.SetUserPassword(user, password).TryGetError(out var error)) {
-					return new UpdatingFailed(error);
+					return new CreateOrUpdateAdministratorUserResult.UpdatingFailed(error);
 				}
 				
 				auditLogWriter.AdministratorUserModified(user);
@@ -71,7 +70,7 @@ sealed class UserManager {
 			
 			var role = await new RoleRepository(db).GetByGuid(Role.Administrator.Guid);
 			if (role == null) {
-				return new AddingToRoleFailed();
+				return new CreateOrUpdateAdministratorUserResult.AddingToRoleFailed();
 			}
 			
 			await new UserRoleRepository(db).Add(user, role);
@@ -85,10 +84,10 @@ sealed class UserManager {
 				Logger.Information("Updated administrator user \"{Username}\" (GUID {Guid}).", username, user.UserGuid);
 			}
 			
-			return new Success(user.ToUserInfo());
+			return new CreateOrUpdateAdministratorUserResult.Success(user.ToUserInfo());
 		} catch (Exception e) {
 			Logger.Error(e, "Could not create or update administrator user \"{Username}\".", username);
-			return new UnknownError();
+			return new CreateOrUpdateAdministratorUserResult.UnknownError();
 		}
 	}
 	
@@ -104,7 +103,7 @@ sealed class UserManager {
 		try {
 			var result = await userRepository.CreateUser(username, password);
 			if (!result) {
-				return new Common.Data.Web.Users.CreateUserResults.CreationFailed(result.Error);
+				return new CreateUserResult.CreationFailed(result.Error);
 			}
 			
 			var user = result.Value;
@@ -113,10 +112,10 @@ sealed class UserManager {
 			await db.Ctx.SaveChangesAsync();
 			
 			Logger.Information("Created user \"{Username}\" (GUID {Guid}).", username, user.UserGuid);
-			return new Common.Data.Web.Users.CreateUserResults.Success(user.ToUserInfo());
+			return new CreateUserResult.Success(user.ToUserInfo());
 		} catch (Exception e) {
 			Logger.Error(e, "Could not create user \"{Username}\".", username);
-			return new Common.Data.Web.Users.CreateUserResults.UnknownError();
+			return new CreateUserResult.UnknownError();
 		}
 	}
 	

Controller/Phantom.Controller/Program.cs

@@ -81,8 +81,8 @@ try {
 	);
 	
 	var rpcServerTasks = new LinkedTasks<bool>([
-		new RpcAgentServer("Agent", agentConnectionParameters, AgentMessageRegistries.Definitions, controllerServices.AgentHandshake, controllerServices.AgentRegistrar).Run(shutdownCancellationToken),
+		new RpcAgentServer("Agent", agentConnectionParameters, AgentMessageRegistries.Registries, controllerServices.AgentHandshake, controllerServices.AgentRegistrar).Run(shutdownCancellationToken),
-		new RpcWebServer("Web", webConnectionParameters, WebMessageRegistries.Definitions, new RpcServerClientHandshake.NoOp(), controllerServices.WebRegistrar).Run(shutdownCancellationToken),
+		new RpcWebServer("Web", webConnectionParameters, WebMessageRegistries.Registries, new RpcServerClientHandshake.NoOp(), controllerServices.WebRegistrar).Run(shutdownCancellationToken),
 	]);
 	
 	// If either RPC server crashes, stop the whole process.

Packages.props

@@ -22,7 +22,7 @@
   
   <ItemGroup>
     <PackageReference Update="BCrypt.Net-Next.StrongName" Version="4.0.3" />
-    <PackageReference Update="MemoryPack"                 Version="1.10.0" />
+    <PackageReference Update="MemoryPack"                 Version="1.21.4" />
   </ItemGroup>
   
   <ItemGroup>

Utils/Phantom.Utils.Rpc/Frame/Types/MessageFrame.cs

@@ -3,7 +3,7 @@ using Phantom.Utils.Rpc.Runtime;
 
 namespace Phantom.Utils.Rpc.Frame.Types;
 
-sealed record MessageFrame(uint MessageId, ushort RegistryCode, ReadOnlyMemory<byte> SerializedMessage) : IFrame {
+sealed record MessageFrame(uint MessageId, byte MessageTypeCode, ReadOnlyMemory<byte> SerializedMessage) : IFrame {
 	public const int MaxMessageBytes = 1024 * 1024 * 8;
 	
 	public ReadOnlyMemory<byte> FrameType => IFrame.TypeMessage;
@@ -13,19 +13,19 @@ sealed record MessageFrame(uint MessageId, ushort RegistryCode, ReadOnlyMemory<b
 		CheckMessageLength(serializedMessageLength);
 		
 		await stream.WriteUnsignedInt(MessageId, cancellationToken);
-		await stream.WriteUnsignedShort(RegistryCode, cancellationToken);
+		await stream.WriteByte(MessageTypeCode, cancellationToken);
 		await stream.WriteUnsignedInt(serializedMessageLength, cancellationToken);
 		await stream.WriteBytes(SerializedMessage, cancellationToken);
 	}
 	
 	public static async Task<MessageFrame> Read(RpcStream stream, CancellationToken cancellationToken) {
 		var messageId = await stream.ReadUnsignedInt(cancellationToken);
-		var registryCode = await stream.ReadUnsignedShort(cancellationToken);
+		var messageTypeCode = await stream.ReadByte(cancellationToken);
 		var serializedMessageLength = await stream.ReadUnsignedInt(cancellationToken);
 		CheckMessageLength(serializedMessageLength);
 		var serializedMessage = await stream.ReadBytes(serializedMessageLength, cancellationToken);
 		
-		return new MessageFrame(messageId, registryCode, serializedMessage);
+		return new MessageFrame(messageId, messageTypeCode, serializedMessage);
 	}
 	
 	private static void CheckMessageLength(uint messageLength) {

Utils/Phantom.Utils.Rpc/Message/IMessageDefinitions.cs

@@ -1,6 +0,0 @@
-namespace Phantom.Utils.Rpc.Message;
-
-public interface IMessageDefinitions<TClientToServerMessage, TServerToClientMessage> {
-	MessageRegistry<TServerToClientMessage> ToClient { get; }
-	MessageRegistry<TClientToServerMessage> ToServer { get; }
-}

Utils/Phantom.Utils.Rpc/Message/MessageRegistries.cs

@@ -0,0 +1,15 @@
+namespace Phantom.Utils.Rpc.Message;
+
+public readonly record struct MessageRegistries<TClientToServerMessage, TServerToClientMessage>(
+	MessageRegistry<TServerToClientMessage> ToClient,
+	MessageRegistry<TClientToServerMessage> ToServer
+) {
+	internal WithMapping CreateMapping() {
+		return new WithMapping(ToClient.CreateMapping(), ToServer.CreateMapping());
+	}
+	
+	internal readonly record struct WithMapping(
+		MessageRegistry<TServerToClientMessage>.WithMapping ToClient,
+		MessageRegistry<TClientToServerMessage>.WithMapping ToServer
+	);
+}

Utils/Phantom.Utils.Rpc/Message/MessageRegistry.cs

@@ -1,75 +1,106 @@
-using System.Diagnostics.CodeAnalysis;
+using System.Collections.Immutable;
 using Phantom.Utils.Actor;
 using Phantom.Utils.Logging;
-using Phantom.Utils.Rpc.Frame.Types;
+using Phantom.Utils.Rpc.Runtime;
 using Serilog;
 
 namespace Phantom.Utils.Rpc.Message;
 
 public sealed class MessageRegistry<TMessageBase>(string loggerName) {
 	private readonly ILogger logger = PhantomLogger.Create<MessageRegistry<TMessageBase>>(loggerName);
-	private readonly Dictionary<Type, ushort> typeToCodeMapping = new ();
+	private readonly List<MessageInfo> messageInfoList = [];
-	private readonly Dictionary<ushort, Registration> codeToRegistrationMapping = new ();
 	
-	private readonly record struct Registration(Type MessageType, Func<uint, ReadOnlyMemory<byte>, MessageHandler<TMessageBase>, CancellationToken, Task> Handler);
+	private readonly record struct MessageInfo(Type Type, MessageTypeName TypeName, DeserializeAndHandleFunc Action);
 	
-	public void Add<TMessage>(ushort code) where TMessage : TMessageBase {
+	internal delegate Task DeserializeAndHandleFunc(uint messageId, ReadOnlyMemory<byte> serializedMessage, MessageHandler<TMessageBase> handler, CancellationToken cancellationToken);
-		Type messageType = typeof(TMessage);
+	
-		
+	public void Add<TMessage>() where TMessage : TMessageBase {
-		if (HasReplyType(messageType)) {
+		if (HasReplyType(typeof(TMessage))) {
 			throw new ArgumentException("This overload is for messages without a reply.");
 		}
 		
-		typeToCodeMapping.Add(messageType, code);
+		AddImpl(typeof(TMessage), DeserializationHandler<TMessage>);
-		codeToRegistrationMapping.Add(code, new Registration(messageType, DeserializationHandler<TMessage>));
 	}
 	
-	public void Add<TMessage, TReply>(ushort code) where TMessage : TMessageBase, ICanReply<TReply> {
+	public void Add<TMessage, TReply>() where TMessage : TMessageBase, ICanReply<TReply> {
-		Type messageType = typeof(TMessage);
+		AddImpl(typeof(TMessage), DeserializationHandler<TMessage, TReply>);
-		
-		typeToCodeMapping.Add(messageType, code);
-		codeToRegistrationMapping.Add(code, new Registration(messageType, DeserializationHandler<TMessage, TReply>));
 	}
 	
-	private bool HasReplyType(Type messageType) {
+	private void AddImpl(Type messageType, DeserializeAndHandleFunc action) {
+		messageInfoList.Add(new MessageInfo(messageType, new MessageTypeName(messageType.Name), action));
+	}
+	
+	private static bool HasReplyType(Type messageType) {
 		string replyInterfaceName = typeof(ICanReply<object>).FullName!;
 		replyInterfaceName = replyInterfaceName[..(replyInterfaceName.IndexOf('`') + 1)];
 		
 		return messageType.GetInterfaces().Any(type => type.FullName is {} name && name.StartsWith(replyInterfaceName, StringComparison.Ordinal));
 	}
 	
-	internal bool TryGetType(MessageFrame frame, [NotNullWhen(true)] out Type? type) {
+	internal WithMapping CreateMapping() {
-		if (codeToRegistrationMapping.TryGetValue(frame.RegistryCode, out var registration)) {
+		var messageTypeNames = ImmutableArray.CreateBuilder<MessageTypeName>();
-			type = registration.MessageType;
+		var messageTypeMapping = new MessageTypeMapping<TMessageBase>.Builder();
-			return true;
-		}
-		else {
-			type = null;
-			return false;
-		}
-	}
-	
-	internal MessageFrame CreateFrame<TMessage>(uint messageId, TMessage message) where TMessage : TMessageBase {
-		if (typeToCodeMapping.TryGetValue(typeof(TMessage), out ushort code)) {
-			return new MessageFrame(messageId, code, MessageSerialization.Serialize(message));
-		}
-		else {
-			throw new ArgumentException("Unknown message type: " + typeof(TMessage));
-		}
-	}
-	
-	internal async Task Handle(MessageFrame frame, MessageHandler<TMessageBase> handler, CancellationToken cancellationToken) {
-		uint messageId = frame.MessageId;
 		
-		if (codeToRegistrationMapping.TryGetValue(frame.RegistryCode, out var registration)) {
+		int nextMessageCode = 0;
-			await registration.Handler(messageId, frame.SerializedMessage, handler, cancellationToken);
+		
+		foreach ((Type messageType, MessageTypeName messageTypeName, DeserializeAndHandleFunc action) in messageInfoList) {
+			if (nextMessageCode == byte.MaxValue) {
+				throw new InvalidOperationException("Trying to register too many messages (" + (nextMessageCode + 1) + ").");
+			}
+			
+			messageTypeNames.Add(messageTypeName);
+			messageTypeMapping.Add((byte) nextMessageCode++, messageType, action);
 		}
-		else {
+		
-			logger.Error("Unknown message code {Code} for message {MessageId}.", frame.RegistryCode, messageId);
+		return new WithMapping(messageTypeNames.ToImmutable(), messageTypeMapping.Build(loggerName));
-			await handler.SendError(messageId, MessageError.UnknownMessageRegistryCode, cancellationToken);
+	}
+	
+	internal sealed class WithMapping(ImmutableArray<MessageTypeName> messageTypeNames, MessageTypeMapping<TMessageBase> mapping) {
+		public MessageTypeMapping<TMessageBase> Mapping => mapping;
+		
+		public async ValueTask Write(RpcStream stream, CancellationToken cancellationToken) {
+			foreach (MessageTypeName typeName in messageTypeNames) {
+				await typeName.Write(stream, cancellationToken);
+			}
+			
+			await MessageTypeName.WriteEnd(stream, cancellationToken);
 		}
 	}
 	
+	internal async ValueTask<ReadMappingResult> ReadMapping(RpcStream stream, CancellationToken cancellationToken) {
+		var messageTypeNameToInfoMapping = messageInfoList.ToImmutableDictionary(static item => item.TypeName, static item => item);
+		
+		var messageTypeMapping = new MessageTypeMapping<TMessageBase>.Builder();
+		var supportedMessages = ImmutableSortedDictionary.CreateBuilder<byte, MessageTypeName>();
+		var unsupportedMessages = ImmutableSortedDictionary.CreateBuilder<byte, MessageTypeName>();
+		
+		byte nextMessageCode = 0;
+		
+		while (await MessageTypeName.Read(stream, cancellationToken) is {} messageTypeName) {
+			if (nextMessageCode == byte.MaxValue) {
+				throw new InvalidOperationException("Trying to register too many messages (" + (nextMessageCode + 1) + ").");
+			}
+			
+			if (messageTypeNameToInfoMapping.TryGetValue(messageTypeName, out var messageInfo)) {
+				messageTypeMapping.Add(nextMessageCode, messageInfo.Type, messageInfo.Action);
+				supportedMessages.Add(nextMessageCode, messageTypeName);
+			}
+			else {
+				unsupportedMessages.Add(nextMessageCode, messageTypeName);
+			}
+			
+			++nextMessageCode;
+		}
+		
+		return new ReadMappingResult(messageTypeMapping.Build(loggerName), supportedMessages.ToImmutable(), unsupportedMessages.ToImmutable());
+	}
+	
+	internal readonly record struct ReadMappingResult(
+		MessageTypeMapping<TMessageBase> TypeMapping,
+		ImmutableSortedDictionary<byte, MessageTypeName> SupportedMessages,
+		ImmutableSortedDictionary<byte, MessageTypeName> UnsupportedMessages
+	);
+	
 	private async Task DeserializationHandler<TMessage>(uint messageId, ReadOnlyMemory<byte> serializedMessage, MessageHandler<TMessageBase> handler, CancellationToken cancellationToken) where TMessage : TMessageBase {
 		TMessage message;
 		try {

Utils/Phantom.Utils.Rpc/Message/MessageTypeMapping.cs

@@ -0,0 +1,68 @@
+using System.Collections.Frozen;
+using System.Diagnostics.CodeAnalysis;
+using Phantom.Utils.Logging;
+using Phantom.Utils.Rpc.Frame.Types;
+using Serilog;
+
+namespace Phantom.Utils.Rpc.Message;
+
+sealed class MessageTypeMapping<TMessageBase> {
+	private readonly ILogger logger;
+	
+	private readonly FrozenDictionary<Type, byte> messageTypeToTypeCodeMapping;
+	private readonly FrozenDictionary<byte, Registration> messageTypeCodeToRegistrationMapping;
+	
+	private MessageTypeMapping(string loggerName, FrozenDictionary<Type, byte> messageTypeToTypeCodeMapping, FrozenDictionary<byte, Registration> messageTypeCodeToRegistrationMapping) {
+		this.logger = PhantomLogger.Create<MessageTypeMapping<TMessageBase>>(loggerName);
+		this.messageTypeToTypeCodeMapping = messageTypeToTypeCodeMapping;
+		this.messageTypeCodeToRegistrationMapping = messageTypeCodeToRegistrationMapping;
+	}
+	
+	private readonly record struct Registration(Type MessageType, MessageRegistry<TMessageBase>.DeserializeAndHandleFunc Action);
+	
+	public bool TryGetType(MessageFrame frame, [NotNullWhen(true)] out Type? type) {
+		if (messageTypeCodeToRegistrationMapping.TryGetValue(frame.MessageTypeCode, out var registration)) {
+			type = registration.MessageType;
+			return true;
+		}
+		else {
+			type = null;
+			return false;
+		}
+	}
+	
+	public MessageFrame CreateFrame<TMessage>(uint messageId, TMessage message) where TMessage : TMessageBase {
+		if (messageTypeToTypeCodeMapping.TryGetValue(typeof(TMessage), out byte messageTypeCode)) {
+			return new MessageFrame(messageId, messageTypeCode, MessageSerialization.Serialize(message));
+		}
+		else {
+			throw new ArgumentException("Unknown message type: " + typeof(TMessage));
+		}
+	}
+	
+	public async Task Handle(MessageFrame frame, MessageHandler<TMessageBase> handler, CancellationToken cancellationToken) {
+		uint messageId = frame.MessageId;
+		
+		if (messageTypeCodeToRegistrationMapping.TryGetValue(frame.MessageTypeCode, out var registration)) {
+			await registration.Action(messageId, frame.SerializedMessage, handler, cancellationToken);
+		}
+		else {
+			logger.Error("Unknown message code {Code} for message {MessageId}.", frame.MessageTypeCode, messageId);
+			await handler.SendError(messageId, MessageError.UnknownMessageRegistryCode, cancellationToken);
+		}
+	}
+	
+	public sealed class Builder {
+		private readonly Dictionary<Type, byte> messageTypeToTypeCodeMapping = new ();
+		private readonly Dictionary<byte, Registration> messageTypeCodeToRegistrationMapping = new ();
+		
+		public void Add(byte messageTypeCode, Type messageType, MessageRegistry<TMessageBase>.DeserializeAndHandleFunc action) {
+			messageTypeToTypeCodeMapping.Add(messageType, messageTypeCode);
+			messageTypeCodeToRegistrationMapping.Add(messageTypeCode, new Registration(messageType, action));
+		}
+		
+		public MessageTypeMapping<TMessageBase> Build(string loggerName) {
+			return new MessageTypeMapping<TMessageBase>(loggerName, messageTypeToTypeCodeMapping.ToFrozenDictionary(), messageTypeCodeToRegistrationMapping.ToFrozenDictionary());
+		}
+	}
+}

Utils/Phantom.Utils.Rpc/Message/MessageTypeMappings.cs

@@ -0,0 +1,6 @@
+namespace Phantom.Utils.Rpc.Message;
+
+readonly record struct MessageTypeMappings<TClientToServerMessage, TServerToClientMessage>(
+	MessageTypeMapping<TServerToClientMessage> ToClient,
+	MessageTypeMapping<TClientToServerMessage> ToServer
+);

Utils/Phantom.Utils.Rpc/Message/MessageTypeName.cs

@@ -0,0 +1,58 @@
+using System.Text;
+using Phantom.Utils.Rpc.Runtime;
+
+namespace Phantom.Utils.Rpc.Message;
+
+sealed class MessageTypeName {
+	private readonly string stringValue;
+	private readonly ReadOnlyMemory<byte> serializedBytes;
+	
+	public MessageTypeName(string name) {
+		this.stringValue = name;
+		this.serializedBytes = Encoding.ASCII.GetBytes(name);
+		
+		if (serializedBytes.Length is 0 or > byte.MaxValue) {
+			throw new ArgumentOutOfRangeException(nameof(name), "Message name must be between 0 and " + byte.MaxValue + " bytes.");
+		}
+	}
+	
+	private MessageTypeName(ReadOnlyMemory<byte> serializedBytes) {
+		this.stringValue = Encoding.ASCII.GetString(serializedBytes.Span);
+		this.serializedBytes = serializedBytes;
+	}
+	
+	public async ValueTask Write(RpcStream stream, CancellationToken cancellationToken) {
+		await stream.WriteByte((byte) serializedBytes.Length, cancellationToken);
+		await stream.WriteBytes(serializedBytes, cancellationToken);
+	}
+	
+	public static async ValueTask WriteEnd(RpcStream stream, CancellationToken cancellationToken) {
+		await stream.WriteByte(value: 0, cancellationToken);
+	}
+	
+	public static async ValueTask<MessageTypeName?> Read(RpcStream stream, CancellationToken cancellationToken) {
+		byte serializedBytesLength = await stream.ReadByte(cancellationToken);
+		if (serializedBytesLength == 0) {
+			return null;
+		}
+		
+		var serializedBytes = await stream.ReadBytes(serializedBytesLength, cancellationToken);
+		return new MessageTypeName(serializedBytes);
+	}
+	
+	public override bool Equals(object? obj) {
+		if (ReferenceEquals(this, obj)) {
+			return true;
+		}
+		
+		return obj is MessageTypeName other && stringValue == other.stringValue;
+	}
+	
+	public override int GetHashCode() {
+		return stringValue.GetHashCode();
+	}
+	
+	public override string ToString() {
+		return stringValue;
+	}
+}

Utils/Phantom.Utils.Rpc/Runtime/Client/RpcClient.cs

@@ -7,21 +7,25 @@ using Serilog;
 namespace Phantom.Utils.Rpc.Runtime.Client;
 
 public sealed class RpcClient<TClientToServerMessage, TServerToClientMessage> : IRpcConnectionProvider, IDisposable {
-	public static async Task<RpcClient<TClientToServerMessage, TServerToClientMessage>?> Connect(string loggerName, RpcClientConnectionParameters connectionParameters, IMessageDefinitions<TClientToServerMessage, TServerToClientMessage> messageDefinitions, CancellationToken cancellationToken) {
+	public static async Task<RpcClient<TClientToServerMessage, TServerToClientMessage>?> Connect(
-		RpcClientToServerConnector connector = new RpcClientToServerConnector(loggerName, connectionParameters);
+		string loggerName,
-		RpcClientToServerConnector.Connection? connection = await connector.ConnectWithRetries(maxAttempts: 10, cancellationToken);
+		RpcClientConnectionParameters connectionParameters,
-		return connection == null ? null : new RpcClient<TClientToServerMessage, TServerToClientMessage>(loggerName, connectionParameters, connector, connection, messageDefinitions);
+		MessageRegistries<TClientToServerMessage, TServerToClientMessage> messageRegistries,
+		CancellationToken cancellationToken
+	) {
+		var connector = new RpcClientToServerConnector<TClientToServerMessage, TServerToClientMessage>(loggerName, connectionParameters, messageRegistries);
+		var connection = await connector.ConnectWithRetries(maxAttempts: 10, cancellationToken);
+		return connection == null ? null : new RpcClient<TClientToServerMessage, TServerToClientMessage>(loggerName, connectionParameters, connector, connection);
 	}
 	
 	private readonly string loggerName;
 	private readonly ILogger logger;
 	
 	private readonly RpcCommonConnectionParameters connectionParameters;
-	private readonly RpcClientToServerConnector connector;
+	private readonly RpcClientToServerConnector<TClientToServerMessage, TServerToClientMessage> connector;
-	private readonly IMessageDefinitions<TClientToServerMessage, TServerToClientMessage> messageDefinitions;
 	private readonly IRpcFrameSenderProvider<TClientToServerMessage>.Mutable frameSenderProvider = new ();
 	
-	private RpcClientToServerConnector.Connection currentConnection;
+	private RpcClientToServerConnector<TClientToServerMessage, TServerToClientMessage>.Connection currentConnection;
 	private readonly SemaphoreSlim currentConnectionSemaphore = new (1);
 	
 	private Task? listenerTask;
@@ -30,14 +34,18 @@ public sealed class RpcClient<TClientToServerMessage, TServerToClientMessage> :
 	
 	public MessageSender<TClientToServerMessage> MessageSender { get; }
 	
-	private RpcClient(string loggerName, RpcCommonConnectionParameters connectionParameters, RpcClientToServerConnector connector, RpcClientToServerConnector.Connection connection, IMessageDefinitions<TClientToServerMessage, TServerToClientMessage> messageDefinitions) {
+	private RpcClient(
+		string loggerName,
+		RpcCommonConnectionParameters connectionParameters,
+		RpcClientToServerConnector<TClientToServerMessage, TServerToClientMessage> connector,
+		RpcClientToServerConnector<TClientToServerMessage, TServerToClientMessage>.Connection connection
+	) {
 		this.loggerName = loggerName;
 		this.logger = PhantomLogger.Create<RpcClient<TClientToServerMessage, TServerToClientMessage>>(loggerName);
 		
 		this.connectionParameters = connectionParameters;
 		this.connector = connector;
 		this.currentConnection = connection;
-		this.messageDefinitions = messageDefinitions;
 		
 		this.MessageSender = new MessageSender<TClientToServerMessage>(loggerName, connectionParameters, frameSenderProvider);
 	}
@@ -46,7 +54,7 @@ public sealed class RpcClient<TClientToServerMessage, TServerToClientMessage> :
 		return (await GetConnection(cancellationToken)).Stream;
 	}
 	
-	private async Task<RpcClientToServerConnector.Connection> GetConnection(CancellationToken cancellationToken) {
+	private async Task<RpcClientToServerConnector<TClientToServerMessage, TServerToClientMessage>.Connection> GetConnection(CancellationToken cancellationToken) {
 		await currentConnectionSemaphore.WaitAsync(cancellationToken);
 		try {
 			if (!currentConnection.Socket.Connected) {
@@ -70,7 +78,7 @@ public sealed class RpcClient<TClientToServerMessage, TServerToClientMessage> :
 	private async Task Listen(IMessageReceiver<TServerToClientMessage> messageReceiver) {
 		CancellationToken cancellationToken = shutdownCancellationTokenSource.Token;
 		
-		RpcClientToServerConnector.Connection? connection = null;
+		RpcClientToServerConnector<TClientToServerMessage, TServerToClientMessage>.Connection? connection = null;
 		SessionState? sessionState = null;
 		
 		try {
@@ -138,10 +146,10 @@ public sealed class RpcClient<TClientToServerMessage, TServerToClientMessage> :
 		}
 	}
 	
-	private SessionState NewSessionState(RpcClientToServerConnector.Connection connection, IMessageReceiver<TServerToClientMessage> messageReceiver) {
+	private SessionState NewSessionState(RpcClientToServerConnector<TClientToServerMessage, TServerToClientMessage>.Connection connection, IMessageReceiver<TServerToClientMessage> messageReceiver) {
-		var frameSender = new RpcFrameSender<TClientToServerMessage>(loggerName, connectionParameters, this, messageDefinitions.ToServer, connection.PingInterval);
+		var frameSender = new RpcFrameSender<TClientToServerMessage>(loggerName, connectionParameters, this, connection.MessageTypeMappings.ToServer, connection.PingInterval);
 		var messageHandler = new MessageHandler<TServerToClientMessage>(messageReceiver, frameSender);
-		var frameReader = new RpcFrameReader<TClientToServerMessage, TServerToClientMessage>(loggerName, connectionParameters, messageDefinitions.ToClient, messageHandler, MessageSender, frameSender);
+		var frameReader = new RpcFrameReader<TClientToServerMessage, TServerToClientMessage>(loggerName, connectionParameters, connection.MessageTypeMappings.ToClient, messageHandler, MessageSender, frameSender);
 		
 		frameSenderProvider.SetNewValue(frameSender);
 		messageReceiver.OnSessionRestarted();
@@ -150,7 +158,7 @@ public sealed class RpcClient<TClientToServerMessage, TServerToClientMessage> :
 	}
 	
 	private readonly record struct SessionState(RpcFrameSender<TClientToServerMessage> FrameSender, RpcFrameReader<TClientToServerMessage, TServerToClientMessage> FrameReader) {
-		public void Update(ILogger logger, RpcClientToServerConnector.Connection connection) {
+		public void Update(ILogger logger, RpcClientToServerConnector<TClientToServerMessage, TServerToClientMessage>.Connection connection) {
 			TimeSpan currentPingInterval = FrameSender.PingInterval;
 			if (currentPingInterval != connection.PingInterval) {
 				logger.Warning("Server requested a different ping interval ({ServerPingInterval}s) than currently set ({ClientPingInterval}s), but ping interval cannot be updated for existing sessions.", connection.PingInterval.TotalSeconds, currentPingInterval.TotalSeconds);

Utils/Phantom.Utils.Rpc/Runtime/Client/RpcClientToServerConnector.cs

@@ -1,30 +1,36 @@
-using System.Net.Security;
+using System.Diagnostics.CodeAnalysis;
+using System.Net.Security;
 using System.Net.Sockets;
 using System.Security.Authentication;
 using System.Security.Cryptography.X509Certificates;
 using Phantom.Utils.Collections;
 using Phantom.Utils.Logging;
+using Phantom.Utils.Rpc.Message;
 using Phantom.Utils.Rpc.Runtime.Tls;
 using Serilog;
+using Serilog.Events;
 
 namespace Phantom.Utils.Rpc.Runtime.Client;
 
-sealed class RpcClientToServerConnector {
+[SuppressMessage("ReSharper", "StaticMemberInGenericType")]
+sealed class RpcClientToServerConnector<TClientToServerMessage, TServerToClientMessage> {
 	private static readonly TimeSpan InitialRetryDelay = TimeSpan.FromMilliseconds(500);
 	private static readonly TimeSpan MaximumRetryDelay = TimeSpan.FromSeconds(30);
 	private static readonly TimeSpan DisconnectTimeout = TimeSpan.FromSeconds(10);
 	
 	private readonly ILogger logger;
-	private readonly Guid sessionId;
 	private readonly RpcClientConnectionParameters parameters;
+	private readonly MessageRegistries<TClientToServerMessage, TServerToClientMessage> messageRegistries;
+	private readonly Guid sessionId;
 	private readonly SslClientAuthenticationOptions sslOptions;
 	
 	private bool loggedCertificateValidationError = false;
 	
-	public RpcClientToServerConnector(string loggerName, RpcClientConnectionParameters parameters) {
+	public RpcClientToServerConnector(string loggerName, RpcClientConnectionParameters parameters, MessageRegistries<TClientToServerMessage, TServerToClientMessage> messageRegistries) {
-		this.logger = PhantomLogger.Create<RpcClientToServerConnector>(loggerName);
+		this.logger = PhantomLogger.Create<RpcClientToServerConnector<TClientToServerMessage, TServerToClientMessage>>(loggerName);
-		this.sessionId = Guid.NewGuid();
 		this.parameters = parameters;
+		this.messageRegistries = messageRegistries;
+		this.sessionId = Guid.NewGuid();
 		
 		this.sslOptions = new SslClientAuthenticationOptions {
 			AllowRenegotiation = false,
@@ -114,7 +120,7 @@ sealed class RpcClientToServerConnector {
 			
 			if (await AuthenticateAndPerformHandshake(stream, cancellationToken) is {} result) {
 				logger.Information("Connected to {Host}:{Port}.", parameters.Host, parameters.Port);
-				return new Connection(clientSocket, stream, result.IsNewSession, result.PingInterval);
+				return new Connection(clientSocket, stream, result.IsNewSession, result.PingInterval, result.MessageTypeMappings);
 			}
 		} catch (Exception e) {
 			logger.Error(e, "Caught unhandled exception.");
@@ -167,13 +173,12 @@ sealed class RpcClientToServerConnector {
 		await stream.WriteGuid(sessionId, cancellationToken);
 		await stream.Flush(cancellationToken);
 		
-		ushort pingIntervalSeconds = await stream.ReadUnsignedShort(cancellationToken);
+		var pingInterval = await ReadPingInterval(stream, cancellationToken);
-		if (pingIntervalSeconds == 0) {
+		if (pingInterval == null) {
-			logger.Error("Server sent invalid ping interval.");
 			return null;
 		}
 		
-		logger.Debug("Server requested a ping interval of {PingInterval}s.", pingIntervalSeconds);
+		var mappedMessageDefinitions = await ReadMessageMappings(stream, cancellationToken);
 		
 		await parameters.Handshake.Perform(stream, cancellationToken);
 		
@@ -183,10 +188,42 @@ sealed class RpcClientToServerConnector {
 			return null;
 		}
 		
-		return new ConnectionResult(finalHandshakeResult == RpcFinalHandshakeResult.NewSession, TimeSpan.FromSeconds(pingIntervalSeconds));
+		return new ConnectionResult(finalHandshakeResult == RpcFinalHandshakeResult.NewSession, pingInterval.Value, mappedMessageDefinitions);
 	}
 	
-	private readonly record struct ConnectionResult(bool IsNewSession, TimeSpan PingInterval);
+	private async Task<TimeSpan?> ReadPingInterval(RpcStream stream, CancellationToken cancellationToken) {
+		ushort pingIntervalSeconds = await stream.ReadUnsignedShort(cancellationToken);
+		if (pingIntervalSeconds == 0) {
+			logger.Error("Server sent invalid ping interval.");
+			return null;
+		}
+		
+		logger.Debug("Server requested a ping interval of {PingInterval}s.", pingIntervalSeconds);
+		return TimeSpan.FromSeconds(pingIntervalSeconds);
+	}
+	
+	private async Task<MessageTypeMappings<TClientToServerMessage, TServerToClientMessage>> ReadMessageMappings(RpcStream stream, CancellationToken cancellationToken) {
+		var toClient = await ReadMessageMapping(messageRegistries.ToClient, stream, cancellationToken);
+		var toServer = await ReadMessageMapping(messageRegistries.ToServer, stream, cancellationToken);
+		
+		return new MessageTypeMappings<TClientToServerMessage, TServerToClientMessage>(toClient, toServer);
+	}
+	
+	private async Task<MessageTypeMapping<TMessageBase>> ReadMessageMapping<TMessageBase>(MessageRegistry<TMessageBase> messageRegistry, RpcStream stream, CancellationToken cancellationToken) {
+		var result = await messageRegistry.ReadMapping(stream, cancellationToken);
+		
+		if (logger.IsEnabled(LogEventLevel.Debug)) {
+			foreach ((byte messageTypeCode, MessageTypeName messageTypeName) in result.SupportedMessages) {
+				logger.Debug("Server requested code {MessageCode} for message {MessageBaseTypeName}:{MessageTypeName}.", messageTypeCode, typeof(TMessageBase).Name, messageTypeName);
+			}
+		}
+		
+		foreach ((byte messageTypeCode, MessageTypeName messageTypeName) in result.UnsupportedMessages) {
+			logger.Warning("Server requested code {MessageCode} for message {MessageBaseTypeName}:{MessageTypeName} that the client does not support.", messageTypeCode, typeof(TMessageBase).Name, messageTypeName);
+		}
+		
+		return result.TypeMapping;
+	}
 	
 	private bool ValidateServerCertificate(object sender, X509Certificate? certificate, X509Chain? chain, SslPolicyErrors sslPolicyErrors) {
 		if (certificate == null || sslPolicyErrors.HasFlag(SslPolicyErrors.RemoteCertificateNotAvailable)) {
@@ -221,7 +258,9 @@ sealed class RpcClientToServerConnector {
 		await socket.DisconnectAsync(reuseSocket: false, timeoutTokenSource.Token);
 	}
 	
-	internal sealed record Connection(Socket Socket, RpcStream Stream, bool IsNewSession, TimeSpan PingInterval) : IAsyncDisposable {
+	private readonly record struct ConnectionResult(bool IsNewSession, TimeSpan PingInterval, MessageTypeMappings<TClientToServerMessage, TServerToClientMessage> MessageTypeMappings);
+	
+	internal sealed record Connection(Socket Socket, RpcStream Stream, bool IsNewSession, TimeSpan PingInterval, MessageTypeMappings<TClientToServerMessage, TServerToClientMessage> MessageTypeMappings) : IAsyncDisposable {
 		public async Task Disconnect() {
 			await DisconnectSocket(Socket, Stream);
 		}

Utils/Phantom.Utils.Rpc/Runtime/RpcFrameReader.cs

@@ -9,7 +9,7 @@ namespace Phantom.Utils.Rpc.Runtime;
 sealed class RpcFrameReader<TSentMessage, TReceivedMessage>(
 	string loggerName,
 	RpcCommonConnectionParameters connectionParameters,
-	MessageRegistry<TReceivedMessage> messageRegistry,
+	MessageTypeMapping<TReceivedMessage> messageTypeMapping,
 	MessageHandler<TReceivedMessage> messageHandler,
 	MessageSender<TSentMessage> messageSender,
 	RpcFrameSender<TSentMessage> frameSender
@@ -38,7 +38,7 @@ sealed class RpcFrameReader<TSentMessage, TReceivedMessage>(
 			return;
 		}
 		
-		if (messageRegistry.TryGetType(frame, out var messageType)) {
+		if (messageTypeMapping.TryGetType(frame, out var messageType)) {
 			logger.Debug("Received message {MesageId} of type {MessageType} ({Bytes} B).", frame.MessageId, messageType.Name, frame.SerializedMessage.Length);
 		}
 		
@@ -58,7 +58,7 @@ sealed class RpcFrameReader<TSentMessage, TReceivedMessage>(
 	
 	private async Task HandleMessage(MessageFrame frame, CancellationToken cancellationToken) {
 		try {
-			await messageRegistry.Handle(frame, messageHandler, cancellationToken);
+			await messageTypeMapping.Handle(frame, messageHandler, cancellationToken);
 		} finally {
 			messageHandlingSemaphore.Release();
 		}

Utils/Phantom.Utils.Rpc/Runtime/RpcFrameSender.cs

@@ -12,7 +12,7 @@ namespace Phantom.Utils.Rpc.Runtime;
 sealed class RpcFrameSender<TMessageBase> : IMessageReplySender {
 	private readonly ILogger logger;
 	private readonly IRpcConnectionProvider connectionProvider;
-	private readonly MessageRegistry<TMessageBase> messageRegistry;
+	private readonly MessageTypeMapping<TMessageBase> messageTypeMapping;
 	private readonly MessageReceiveTracker messageReceiveTracker = new ();
 	
 	private readonly Channel<IFrame> frameQueue;
@@ -27,10 +27,10 @@ sealed class RpcFrameSender<TMessageBase> : IMessageReplySender {
 	
 	internal TimeSpan PingInterval { get; }
 	
-	internal RpcFrameSender(string loggerName, RpcCommonConnectionParameters connectionParameters, IRpcConnectionProvider connectionProvider, MessageRegistry<TMessageBase> messageRegistry, TimeSpan pingInterval) {
+	internal RpcFrameSender(string loggerName, RpcCommonConnectionParameters connectionParameters, IRpcConnectionProvider connectionProvider, MessageTypeMapping<TMessageBase> messageTypeMapping, TimeSpan pingInterval) {
 		this.logger = PhantomLogger.Create<RpcFrameSender<TMessageBase>>(loggerName);
 		this.connectionProvider = connectionProvider;
-		this.messageRegistry = messageRegistry;
+		this.messageTypeMapping = messageTypeMapping;
 		
 		this.frameQueue = Channel.CreateBounded<IFrame>(new BoundedChannelOptions(connectionParameters.FrameQueueCapacity) {
 			AllowSynchronousContinuations = false,
@@ -50,7 +50,7 @@ sealed class RpcFrameSender<TMessageBase> : IMessageReplySender {
 	}
 	
 	public async ValueTask SendMessage<TMessage>(uint messageId, TMessage message, CancellationToken cancellationToken) where TMessage : TMessageBase {
-		var frame = messageRegistry.CreateFrame(messageId, message);
+		var frame = messageTypeMapping.CreateFrame(messageId, message);
 		logger.Debug("Sending message {MesageId} of type {MessageType} ({MessageBytes} B).", messageId, typeof(TMessage).Name, frame.SerializedMessage.Length);
 		await SendFrame(frame, cancellationToken);
 	}

Utils/Phantom.Utils.Rpc/Runtime/Server/RpcServer.cs

@@ -10,17 +10,33 @@ using Serilog;
 
 namespace Phantom.Utils.Rpc.Runtime.Server;
 
-public sealed class RpcServer<TClientToServerMessage, TServerToClientMessage, THandshakeResult>(
+public sealed class RpcServer<TClientToServerMessage, TServerToClientMessage, THandshakeResult> {
-	string loggerName,
+	private readonly string loggerName;
-	RpcServerConnectionParameters connectionParameters,
+	private readonly ILogger logger;
-	IMessageDefinitions<TClientToServerMessage, TServerToClientMessage> messageDefinitions,
+	private readonly RpcServerConnectionParameters connectionParameters;
-	IRpcServerClientHandshake<THandshakeResult> clientHandshake,
+	private readonly MessageRegistries<TClientToServerMessage, TServerToClientMessage>.WithMapping messageRegistries;
-	IRpcServerClientRegistrar<TClientToServerMessage, TServerToClientMessage, THandshakeResult> clientRegistrar
+	private readonly IRpcServerClientHandshake<THandshakeResult> clientHandshake;
-) {
+	private readonly IRpcServerClientRegistrar<TClientToServerMessage, TServerToClientMessage, THandshakeResult> clientRegistrar;
-	private readonly ILogger logger = PhantomLogger.Create<RpcServer<TClientToServerMessage, TServerToClientMessage, THandshakeResult>>(loggerName);
+	
-	private readonly RpcServerClientSessions<TServerToClientMessage> clientSessions = new (loggerName, connectionParameters, messageDefinitions.ToClient);
+	private readonly RpcServerClientSessions<TServerToClientMessage> clientSessions;
 	private readonly List<Client> clients = [];
 	
+	public RpcServer(
+		string loggerName,
+		RpcServerConnectionParameters connectionParameters,
+		MessageRegistries<TClientToServerMessage, TServerToClientMessage> messageRegistries,
+		IRpcServerClientHandshake<THandshakeResult> clientHandshake,
+		IRpcServerClientRegistrar<TClientToServerMessage, TServerToClientMessage, THandshakeResult> clientRegistrar
+	) {
+		this.loggerName = loggerName;
+		this.logger = PhantomLogger.Create<RpcServer<TClientToServerMessage, TServerToClientMessage, THandshakeResult>>(loggerName);
+		this.connectionParameters = connectionParameters;
+		this.messageRegistries = messageRegistries.CreateMapping();
+		this.clientHandshake = clientHandshake;
+		this.clientRegistrar = clientRegistrar;
+		this.clientSessions = new RpcServerClientSessions<TServerToClientMessage>(loggerName, connectionParameters, this.messageRegistries.ToClient.Mapping);
+	}
+	
 	public async Task<bool> Run(CancellationToken shutdownToken) {
 		EndPoint endPoint = connectionParameters.EndPoint;
 		
@@ -36,7 +52,7 @@ public sealed class RpcServer<TClientToServerMessage, TServerToClientMessage, TH
 		
 		var serverData = new SharedData(
 			connectionParameters,
-			messageDefinitions.ToServer,
+			messageRegistries,
 			clientHandshake,
 			clientRegistrar,
 			clientSessions
@@ -94,7 +110,7 @@ public sealed class RpcServer<TClientToServerMessage, TServerToClientMessage, TH
 	
 	private readonly record struct SharedData(
 		RpcServerConnectionParameters ConnectionParameters,
-		MessageRegistry<TClientToServerMessage> MessageRegistry,
+		MessageRegistries<TClientToServerMessage, TServerToClientMessage>.WithMapping MessageDefinitions,
 		IRpcServerClientHandshake<THandshakeResult> ClientHandshake,
 		IRpcServerClientRegistrar<TClientToServerMessage, TServerToClientMessage, THandshakeResult> ClientRegistrar,
 		RpcServerClientSessions<TServerToClientMessage> ClientSessions
@@ -226,6 +242,8 @@ public sealed class RpcServer<TClientToServerMessage, TServerToClientMessage, TH
 				}
 				
 				await stream.WriteUnsignedShort(sharedData.ConnectionParameters.PingIntervalSeconds, cancellationToken);
+				await sharedData.MessageDefinitions.ToClient.Write(stream, cancellationToken);
+				await sharedData.MessageDefinitions.ToServer.Write(stream, cancellationToken);
 				await stream.Flush(cancellationToken);
 				
 				var sessionId = await stream.ReadGuid(cancellationToken);
@@ -263,7 +281,7 @@ public sealed class RpcServer<TClientToServerMessage, TServerToClientMessage, TH
 			switch (await sharedData.ClientHandshake.Perform(session.IsNew, stream, cancellationToken)) {
 				case Left<THandshakeResult, Exception>(var handshakeResult):
 					try {
-						var connection = new RpcServerToClientConnection<TClientToServerMessage, TServerToClientMessage>(sharedData.ConnectionParameters, sharedData.MessageRegistry, session, stream);
+						var connection = new RpcServerToClientConnection<TClientToServerMessage, TServerToClientMessage>(sharedData.ConnectionParameters, sharedData.MessageDefinitions.ToServer.Mapping, session, stream);
 						var messageReceiver = sharedData.ClientRegistrar.Register(connection, handshakeResult);
 						
 						return new EstablishedConnection(session, connection, messageReceiver);

Utils/Phantom.Utils.Rpc/Runtime/Server/RpcServerClientSession.cs

@@ -28,12 +28,12 @@ sealed class RpcServerClientSession<TServerToClientMessage> : IRpcConnectionProv
 	
 	public CancellationToken CloseCancellationToken => closeCancellationTokenSource.Token;
 	
-	public RpcServerClientSession(string loggerName, RpcServerConnectionParameters connectionParameters, MessageRegistry<TServerToClientMessage> messageRegistry, RpcServerClientSessions<TServerToClientMessage> sessions, Guid sessionId) {
+	public RpcServerClientSession(string loggerName, RpcServerConnectionParameters connectionParameters, MessageTypeMapping<TServerToClientMessage> messageTypeMapping, RpcServerClientSessions<TServerToClientMessage> sessions, Guid sessionId) {
 		this.logger = PhantomLogger.Create<RpcServerClientSession<TServerToClientMessage>>(loggerName);
 		this.LoggerName = loggerName;
 		this.sessions = sessions;
 		this.SessionId = sessionId;
-		this.FrameSender = new RpcFrameSender<TServerToClientMessage>(loggerName, connectionParameters, this, messageRegistry, connectionParameters.PingInterval);
+		this.FrameSender = new RpcFrameSender<TServerToClientMessage>(loggerName, connectionParameters, this, messageTypeMapping, connectionParameters.PingInterval);
 		this.MessageSender = new MessageSender<TServerToClientMessage>(loggerName, connectionParameters, new IRpcFrameSenderProvider<TServerToClientMessage>.Constant(FrameSender));
 		
 		this.closeAfterDisconnectionTimer = new Timer(DisconnectedSessionTimeout) { AutoReset = false };

Utils/Phantom.Utils.Rpc/Runtime/Server/RpcServerClientSessions.cs

@@ -7,7 +7,7 @@ namespace Phantom.Utils.Rpc.Runtime.Server;
 sealed class RpcServerClientSessions<TServerToClientMessage> {
 	private readonly string loggerName;
 	private readonly RpcServerConnectionParameters connectionParameters;
-	private readonly MessageRegistry<TServerToClientMessage> messageRegistry;
+	private readonly MessageTypeMapping<TServerToClientMessage> messageTypeMapping;
 	
 	private readonly ConcurrentDictionary<Guid, RpcServerClientSession<TServerToClientMessage>> sessionsById = new ();
 	
@@ -16,10 +16,10 @@ sealed class RpcServerClientSessions<TServerToClientMessage> {
 	
 	public int Count => sessionsById.Count;
 	
-	public RpcServerClientSessions(string loggerName, RpcServerConnectionParameters connectionParameters, MessageRegistry<TServerToClientMessage> messageRegistry) {
+	public RpcServerClientSessions(string loggerName, RpcServerConnectionParameters connectionParameters, MessageTypeMapping<TServerToClientMessage> messageTypeMapping) {
 		this.loggerName = loggerName;
 		this.connectionParameters = connectionParameters;
-		this.messageRegistry = messageRegistry;
+		this.messageTypeMapping = messageTypeMapping;
 		this.createSessionFunction = CreateSession;
 	}
 	
@@ -28,7 +28,7 @@ sealed class RpcServerClientSessions<TServerToClientMessage> {
 	}
 	
 	private RpcServerClientSession<TServerToClientMessage> CreateSession(Guid sessionId) {
-		return new RpcServerClientSession<TServerToClientMessage>(NextLoggerName(sessionId), connectionParameters, messageRegistry, this, sessionId);
+		return new RpcServerClientSession<TServerToClientMessage>(NextLoggerName(sessionId), connectionParameters, messageTypeMapping, this, sessionId);
 	}
 	
 	private string NextLoggerName(Guid sessionId) {

Utils/Phantom.Utils.Rpc/Runtime/Server/RpcServerToClientConnection.cs

@@ -8,24 +8,29 @@ namespace Phantom.Utils.Rpc.Runtime.Server;
 public sealed class RpcServerToClientConnection<TClientToServerMessage, TServerToClientMessage> {
 	private readonly ILogger logger;
 	private readonly RpcCommonConnectionParameters connectionParameters;
-	private readonly MessageRegistry<TClientToServerMessage> messageRegistry;
+	private readonly MessageTypeMapping<TClientToServerMessage> messageTypeMapping;
 	private readonly RpcServerClientSession<TServerToClientMessage> session;
 	private readonly RpcStream stream;
 	
 	public Guid SessionId => session.SessionId;
 	public MessageSender<TServerToClientMessage> MessageSender => session.MessageSender;
 	
-	internal RpcServerToClientConnection(RpcCommonConnectionParameters connectionParameters, MessageRegistry<TClientToServerMessage> messageRegistry, RpcServerClientSession<TServerToClientMessage> session, RpcStream stream) {
+	internal RpcServerToClientConnection(
+		RpcCommonConnectionParameters connectionParameters,
+		MessageTypeMapping<TClientToServerMessage> messageTypeMapping,
+		RpcServerClientSession<TServerToClientMessage> session,
+		RpcStream stream
+	) {
 		this.logger = PhantomLogger.Create<RpcServerToClientConnection<TClientToServerMessage, TServerToClientMessage>>(session.LoggerName);
 		this.connectionParameters = connectionParameters;
-		this.messageRegistry = messageRegistry;
+		this.messageTypeMapping = messageTypeMapping;
 		this.session = session;
 		this.stream = stream;
 	}
 	
 	internal async Task Listen(IMessageReceiver<TClientToServerMessage> messageReceiver) {
 		var messageHandler = new MessageHandler<TClientToServerMessage>(messageReceiver, session.FrameSender);
-		var frameReader = new RpcFrameReader<TServerToClientMessage, TClientToServerMessage>(session.LoggerName, connectionParameters, messageRegistry, messageHandler, MessageSender, session.FrameSender);
+		var frameReader = new RpcFrameReader<TServerToClientMessage, TClientToServerMessage>(session.LoggerName, connectionParameters, messageTypeMapping, messageHandler, MessageSender, session.FrameSender);
 		
 		try {
 			await IFrame.ReadFrom(stream, frameReader, session.CloseCancellationToken);

Web/Phantom.Web/Pages/InstanceDetail.razor

@@ -1,12 +1,12 @@
 @page "/instances/{InstanceGuid:guid}"
 @attribute [Authorize(Permission.ViewInstancesPolicy)]
+@using Phantom.Common.Data.Instance
 @using Phantom.Common.Data.Replies
 @using Phantom.Common.Data.Web.Instance
 @using Phantom.Common.Data.Web.Users
 @using Phantom.Utils.Result
-@using Phantom.Common.Data.Instance
-@using Phantom.Web.Services.Instances
 @using Phantom.Web.Services.Authorization
+@using Phantom.Web.Services.Instances
 @inherits PhantomComponent
 @inject InstanceManager InstanceManager
 
@@ -101,11 +101,11 @@
           lastError = launchInstanceResult.ToSentence();
           break;
 
-        case Err<UserInstanceActionFailure>(OfInstanceActionFailure(var failure)):
+        case Err<UserInstanceActionFailure>(UserInstanceActionFailure.Instance(var failure)):
           lastError = failure.ToSentence();
           break;
 
-        case Err<UserInstanceActionFailure>(OfUserActionFailure(UserActionFailure.NotAuthorized)):
+        case Err<UserInstanceActionFailure>(UserInstanceActionFailure.User(UserActionFailure.NotAuthorized)):
           lastError = "You do not have permission to launch this instance.";
           break;
 

Web/Phantom.Web/Pages/Setup.razor

@@ -3,7 +3,6 @@
 @using System.Security.Cryptography
 @using Phantom.Common.Data
 @using Phantom.Common.Data.Web.Users
-@using Phantom.Common.Data.Web.Users.CreateOrUpdateAdministratorUserResults
 @using Phantom.Common.Messages.Web.ToController
 @using Phantom.Utils.Cryptography
 @using Phantom.Web.Services
@@ -91,12 +90,12 @@
   private async Task<Result<string>> CreateOrUpdateAdministrator() {
     var reply = await ControllerConnection.Send<CreateOrUpdateAdministratorUserMessage, CreateOrUpdateAdministratorUserResult>(new CreateOrUpdateAdministratorUserMessage(form.Username, form.Password), Timeout.InfiniteTimeSpan);
     return reply switch {
-      Success             => Result.Ok,
+      CreateOrUpdateAdministratorUserResult.Success             => Result.Ok,
-      CreationFailed fail => fail.Error.ToSentences("\n"),
+      CreateOrUpdateAdministratorUserResult.CreationFailed fail => fail.Error.ToSentences("\n"),
-      UpdatingFailed fail => fail.Error.ToSentences("\n"),
+      CreateOrUpdateAdministratorUserResult.UpdatingFailed fail => fail.Error.ToSentences("\n"),
-      AddingToRoleFailed  => "Could not assign administrator role to user.",
+      CreateOrUpdateAdministratorUserResult.AddingToRoleFailed  => "Could not assign administrator role to user.",
-      null                => "Timed out.",
+      null                                                      => "Timed out.",
-      _                   => "Unknown error.",
+      _                                                         => "Unknown error.",
     };
   }
 

Web/Phantom.Web/Program.cs

@@ -63,7 +63,7 @@ try {
 		MaxConcurrentlyHandledMessages: 100
 	);
 	
-	using var rpcClient = await RpcClient<IMessageToController, IMessageToWeb>.Connect("Controller", rpcClientConnectionParameters, WebMessageRegistries.Definitions, shutdownCancellationToken);
+	using var rpcClient = await RpcClient<IMessageToController, IMessageToWeb>.Connect("Controller", rpcClientConnectionParameters, WebMessageRegistries.Registries, shutdownCancellationToken);
 	if (rpcClient == null) {
 		PhantomLogger.Root.Fatal("Could not connect to Phantom Controller, shutting down.");
 		return 1;

Web/Phantom.Web/Shared/InstanceAddOrEditForm.razor

@@ -351,11 +351,11 @@
         form.SubmitModel.StopSubmitting(createOrUpdateInstanceResult.ToSentence());
         break;
 
-      case Err<UserInstanceActionFailure>(OfInstanceActionFailure(var failure)):
+      case Err<UserInstanceActionFailure>(UserInstanceActionFailure.Instance(var failure)):
         form.SubmitModel.StopSubmitting(failure.ToSentence());
         break;
 
-      case Err<UserInstanceActionFailure>(OfUserActionFailure(UserActionFailure.NotAuthorized)):
+      case Err<UserInstanceActionFailure>(UserInstanceActionFailure.User(UserActionFailure.NotAuthorized)):
         form.SubmitModel.StopSubmitting("You do not have permission to create or edit instances.");
         break;
 

Web/Phantom.Web/Shared/InstanceCommandInput.razor

@@ -2,7 +2,7 @@
 @using Phantom.Common.Data.Web.Users
 @using Phantom.Utils.Result
 @using Phantom.Web.Services.Instances
-@inherits Phantom.Web.Components.PhantomComponent
+@inherits PhantomComponent
 @inject InstanceManager InstanceManager
 
 <Form Model="form" OnSubmit="ExecuteCommand">
@@ -49,11 +49,11 @@
         form.SubmitModel.StopSubmitting(sendCommandToInstanceResult.ToSentence());
         break;
 
-      case Err<UserInstanceActionFailure>(OfInstanceActionFailure(var failure)):
+      case Err<UserInstanceActionFailure>(UserInstanceActionFailure.Instance(var failure)):
         form.SubmitModel.StopSubmitting(failure.ToSentence());
         break;
 
-      case Err<UserInstanceActionFailure>(OfUserActionFailure(UserActionFailure.NotAuthorized)):
+      case Err<UserInstanceActionFailure>(UserInstanceActionFailure.User(UserActionFailure.NotAuthorized)):
         form.SubmitModel.StopSubmitting("You do not have permission to send commands to this instance.");
         break;
 

Web/Phantom.Web/Shared/InstanceStopDialog.razor

@@ -1,10 +1,10 @@
-@using Phantom.Common.Data.Replies
+@using System.ComponentModel.DataAnnotations
+@using Phantom.Common.Data.Minecraft
+@using Phantom.Common.Data.Replies
 @using Phantom.Common.Data.Web.Users
 @using Phantom.Utils.Result
 @using Phantom.Web.Services.Instances
-@using System.ComponentModel.DataAnnotations
+@inherits PhantomComponent
-@using Phantom.Common.Data.Minecraft
-@inherits Phantom.Web.Components.PhantomComponent
 @inject IJSRuntime Js;
 @inject InstanceManager InstanceManager;
 
@@ -66,11 +66,11 @@
         form.SubmitModel.StopSubmitting(stopInstanceResult.ToSentence());
         break;
 
-      case Err<UserInstanceActionFailure>(OfInstanceActionFailure(var failure)):
+      case Err<UserInstanceActionFailure>(UserInstanceActionFailure.Instance(var failure)):
         form.SubmitModel.StopSubmitting(failure.ToSentence());
         break;
 
-      case Err<UserInstanceActionFailure>(OfUserActionFailure(UserActionFailure.NotAuthorized)):
+      case Err<UserInstanceActionFailure>(UserInstanceActionFailure.User(UserActionFailure.NotAuthorized)):
         form.SubmitModel.StopSubmitting("You do not have permission to stop this instance.");
         break;
 

Web/Phantom.Web/Shared/UserAddDialog.razor

@@ -1,9 +1,8 @@
-@using Phantom.Common.Data.Web.Users
+@using System.ComponentModel.DataAnnotations
-@using Phantom.Common.Data.Web.Users.CreateUserResults
+@using Phantom.Common.Data.Web.Users
 @using Phantom.Utils.Result
 @using Phantom.Web.Services.Users
-@using System.ComponentModel.DataAnnotations
+@inherits PhantomComponent
-@inherits Phantom.Web.Components.PhantomComponent
 @inject IJSRuntime Js;
 @inject UserManager UserManager;
 
@@ -56,13 +55,13 @@
     var result = await UserManager.Create(await GetAuthenticatedUser(), form.Username, form.Password, CancellationToken);
 
     switch (result.Variant()) {
-      case Ok<CreateUserResult>(Success success):
+      case Ok<CreateUserResult>(CreateUserResult.Success success):
         await UserAdded.InvokeAsync(success.User);
         await Js.InvokeVoidAsync("closeModal", ModalId);
         form.SubmitModel.StopSubmitting();
         break;
 
-      case Ok<CreateUserResult>(CreationFailed fail):
+      case Ok<CreateUserResult>(CreateUserResult.CreationFailed fail):
         form.SubmitModel.StopSubmitting(fail.Error.ToSentences("\n"));
         break;
 

Web/Phantom.Web/Utils/Messages.cs

@@ -2,47 +2,42 @@
 using Phantom.Common.Data.Replies;
 using Phantom.Common.Data.Web.Minecraft;
 using Phantom.Common.Data.Web.Users;
-using Phantom.Common.Data.Web.Users.AddUserErrors;
-using Phantom.Common.Data.Web.Users.PasswordRequirementViolations;
-using Phantom.Common.Data.Web.Users.SetUserPasswordErrors;
-using Phantom.Common.Data.Web.Users.UsernameRequirementViolations;
-using PasswordIsInvalid = Phantom.Common.Data.Web.Users.AddUserErrors.PasswordIsInvalid;
 
 namespace Phantom.Web.Utils;
 
 static class Messages {
 	public static string ToSentences(this AddUserError error, string delimiter) {
 		return error switch {
-			NameIsInvalid e     => e.Violation.ToSentence(),
+			AddUserError.NameIsInvalid e     => e.Violation.ToSentence(),
-			PasswordIsInvalid e => string.Join(delimiter, e.Violations.Select(static v => v.ToSentence())),
+			AddUserError.PasswordIsInvalid e => string.Join(delimiter, e.Violations.Select(static v => v.ToSentence())),
-			NameAlreadyExists   => "Username is already occupied.",
+			AddUserError.NameAlreadyExists   => "Username is already occupied.",
-			_                   => "Unknown error.",
+			_                                => "Unknown error.",
 		};
 	}
 	
 	public static string ToSentences(this SetUserPasswordError error, string delimiter) {
 		return error switch {
-			UserNotFound                                                    => "User not found.",
+			SetUserPasswordError.UserNotFound        => "User not found.",
-			Common.Data.Web.Users.SetUserPasswordErrors.PasswordIsInvalid e => string.Join(delimiter, e.Violations.Select(static v => v.ToSentence())),
+			SetUserPasswordError.PasswordIsInvalid e => string.Join(delimiter, e.Violations.Select(static v => v.ToSentence())),
-			_                                                               => "Unknown error.",
+			_                                        => "Unknown error.",
 		};
 	}
 	
 	public static string ToSentence(this UsernameRequirementViolation violation) {
 		return violation switch {
-			IsEmpty   => "Username must not be empty.",
+			UsernameRequirementViolation.IsEmpty   => "Username must not be empty.",
-			TooLong v => "Username must not be longer than " + v.MaxLength + " character(s).",
+			UsernameRequirementViolation.TooLong v => "Username must not be longer than " + v.MaxLength + " character(s).",
-			_         => "Unknown error.",
+			_                                      => "Unknown error.",
 		};
 	}
 	
 	public static string ToSentence(this PasswordRequirementViolation violation) {
 		return violation switch {
-			TooShort v                 => "Password must be at least " + v.MinimumLength + " character(s) long.",
+			PasswordRequirementViolation.TooShort v                 => "Password must be at least " + v.MinimumLength + " character(s) long.",
-			MustContainLowercaseLetter => "Password must contain a lowercase letter.",
+			PasswordRequirementViolation.MustContainLowercaseLetter => "Password must contain a lowercase letter.",
-			MustContainUppercaseLetter => "Password must contain an uppercase letter.",
+			PasswordRequirementViolation.MustContainUppercaseLetter => "Password must contain an uppercase letter.",
-			MustContainDigit           => "Password must contain a digit.",
+			PasswordRequirementViolation.MustContainDigit           => "Password must contain a digit.",
-			_                          => "Unknown error.",
+			_                                                       => "Unknown error.",
 		};
 	}