From f024f46b0b4c517848471be9ef6cac1c695d57b3 Mon Sep 17 00:00:00 2001
From: Lyndomen <49795619+Lyndomen@users.noreply.github.com>
Date: Tue, 11 Mar 2025 11:34:45 -0400
Subject: [PATCH] Port Height & Records Computer from Cosmatic Drift (#2236)

* Port character records from CD

* Make species' base scales respected by CD heights

* Hide the height editor in the humanoid profile editor

---------

Co-authored-by: Janet Blackquill <uhhadd@gmail.com>
---
 .../UI/Tabs/AdminTab/AdminTab.xaml            |    3 +
 .../Humanoid/HumanoidAppearanceSystem.cs      |   10 +
 .../Lobby/UI/HumanoidProfileEditor.xaml       |    9 +
 .../Lobby/UI/HumanoidProfileEditor.xaml.cs    |  104 +
 .../_CD/Admin/UI/ModifyCharacterRecords.xaml  |   14 +
 .../Admin/UI/ModifyCharacterRecords.xaml.cs   |   48 +
 ...haracterRecordConsoleBoundUserInterface.cs |   75 +
 .../_CD/Records/UI/CharacterRecordViewer.xaml |  117 +
 .../Records/UI/CharacterRecordViewer.xaml.cs  |  450 ++++
 .../Records/UI/RecordEditorEntrySelector.xaml |   14 +
 .../UI/RecordEditorEntrySelector.xaml.cs      |  135 +
 .../_CD/Records/UI/RecordEditorGui.xaml       |   68 +
 .../_CD/Records/UI/RecordEditorGui.xaml.cs    |  155 ++
 .../_CD/Records/UI/RecordEntryEditPopup.xaml  |   36 +
 .../Records/UI/RecordEntryEditPopup.xaml.cs   |  145 ++
 .../_CD/Records/UI/RecordEntryViewPopup.xaml  |   38 +
 .../Records/UI/RecordEntryViewPopup.xaml.cs   |   46 +
 .../_CD/Records/UI/RecordLongItemDisplay.cs   |   65 +
 .../_CD/Records/UI/UnitConversion.cs          |   16 +
 Content.Server.Database/CDModel.cs            |   56 +
 ..._CosmaticDriftCharacterRecords.Designer.cs | 2216 +++++++++++++++++
 ...303043202_CosmaticDriftCharacterRecords.cs |   86 +
 .../PostgresServerDbContextModelSnapshot.cs   |  104 +
 ..._CosmaticDriftCharacterRecords.Designer.cs | 2137 ++++++++++++++++
 ...303043130_CosmaticDriftCharacterRecords.cs |   84 +
 .../SqliteServerDbContextModelSnapshot.cs     |  101 +
 Content.Server.Database/Model.cs              |   16 +
 Content.Server.Database/ModelSqlite.cs        |    6 +
 Content.Server/Database/ServerDbBase.cs       |   30 +-
 .../CharacterRecordKeyStorageComponent.cs     |   17 +
 .../_CD/Records/CharacterRecordsComponent.cs  |   31 +
 .../_CD/Records/CharacterRecordsSystem.cs     |  194 ++
 .../Records/Commands/DelRecordEntryCommand.cs |   55 +
 .../Commands/PurgeCharacterRecordsCommand.cs  |   42 +
 .../CharacterRecordConsoleComponent.cs        |   17 +
 .../Consoles/CharacterRecordConsoleSystem.cs  |  152 ++
 .../_CD/Records/RecordsSerialization.cs       |   93 +
 .../SkipLoadingCharacterRecordsComponent.cs   |    4 +
 .../Humanoid/HumanoidAppearanceComponent.cs   |    8 +
 .../Humanoid/Prototypes/SpeciesPrototype.cs   |   46 +
 .../SharedHumanoidAppearanceSystem.cs         |    3 +
 .../Preferences/HumanoidCharacterProfile.cs   |   61 +-
 .../_CD/Records/FullCharacterRecords.cs       |   94 +
 .../Records/PlayerProvidedCharacterRecords.cs |  268 ++
 .../Records/SharedCharacterRecordConsole.cs   |   80 +
 Resources/Locale/en-US/_CD/admin/admin.ftl    |   11 +
 .../Locale/en-US/_CD/guidebook/guides.ftl     |   16 +
 .../ui/humanoid-profile-editor.ftl            |    2 +
 .../Locale/en-US/_CD/records/corrections.ftl  |    5 +
 Resources/Locale/en-US/_CD/records/editor.ftl |   40 +
 Resources/Locale/en-US/_CD/records/viewer.ftl |   26 +
 .../Entities/Mobs/Player/admin_ghost.yml      |   28 +
 .../Machines/Computers/computers.yml          |   34 +-
 Resources/Prototypes/Guidebook/newplayer.yml  |    3 +-
 .../Prototypes/Nyanotrasen/Species/Oni.yml    |    1 +
 .../Nyanotrasen/Species/felinid.yml           |    1 +
 .../Prototypes/_CD/Guidebook/features.yml     |    4 +
 Resources/Prototypes/_DV/Species/harpy.yml    |    1 +
 Resources/Prototypes/_DV/Species/rodentia.yml |    1 +
 .../Prototypes/_Impstation/Species/thaven.yml |    1 +
 .../ServerInfo/Guidebook/_CD/Records.xml      |   40 +
 61 files changed, 7753 insertions(+), 10 deletions(-)
 create mode 100644 Content.Client/_CD/Admin/UI/ModifyCharacterRecords.xaml
 create mode 100644 Content.Client/_CD/Admin/UI/ModifyCharacterRecords.xaml.cs
 create mode 100644 Content.Client/_CD/Records/UI/CharacterRecordConsoleBoundUserInterface.cs
 create mode 100644 Content.Client/_CD/Records/UI/CharacterRecordViewer.xaml
 create mode 100644 Content.Client/_CD/Records/UI/CharacterRecordViewer.xaml.cs
 create mode 100644 Content.Client/_CD/Records/UI/RecordEditorEntrySelector.xaml
 create mode 100644 Content.Client/_CD/Records/UI/RecordEditorEntrySelector.xaml.cs
 create mode 100644 Content.Client/_CD/Records/UI/RecordEditorGui.xaml
 create mode 100644 Content.Client/_CD/Records/UI/RecordEditorGui.xaml.cs
 create mode 100644 Content.Client/_CD/Records/UI/RecordEntryEditPopup.xaml
 create mode 100644 Content.Client/_CD/Records/UI/RecordEntryEditPopup.xaml.cs
 create mode 100644 Content.Client/_CD/Records/UI/RecordEntryViewPopup.xaml
 create mode 100644 Content.Client/_CD/Records/UI/RecordEntryViewPopup.xaml.cs
 create mode 100644 Content.Client/_CD/Records/UI/RecordLongItemDisplay.cs
 create mode 100644 Content.Client/_CD/Records/UI/UnitConversion.cs
 create mode 100644 Content.Server.Database/CDModel.cs
 create mode 100644 Content.Server.Database/Migrations/Postgres/20250303043202_CosmaticDriftCharacterRecords.Designer.cs
 create mode 100644 Content.Server.Database/Migrations/Postgres/20250303043202_CosmaticDriftCharacterRecords.cs
 create mode 100644 Content.Server.Database/Migrations/Sqlite/20250303043130_CosmaticDriftCharacterRecords.Designer.cs
 create mode 100644 Content.Server.Database/Migrations/Sqlite/20250303043130_CosmaticDriftCharacterRecords.cs
 create mode 100644 Content.Server/_CD/Records/CharacterRecordKeyStorageComponent.cs
 create mode 100644 Content.Server/_CD/Records/CharacterRecordsComponent.cs
 create mode 100644 Content.Server/_CD/Records/CharacterRecordsSystem.cs
 create mode 100644 Content.Server/_CD/Records/Commands/DelRecordEntryCommand.cs
 create mode 100644 Content.Server/_CD/Records/Commands/PurgeCharacterRecordsCommand.cs
 create mode 100644 Content.Server/_CD/Records/Consoles/CharacterRecordConsoleComponent.cs
 create mode 100644 Content.Server/_CD/Records/Consoles/CharacterRecordConsoleSystem.cs
 create mode 100644 Content.Server/_CD/Records/RecordsSerialization.cs
 create mode 100644 Content.Server/_CD/Records/SkipLoadingCharacterRecordsComponent.cs
 create mode 100644 Content.Shared/_CD/Records/FullCharacterRecords.cs
 create mode 100644 Content.Shared/_CD/Records/PlayerProvidedCharacterRecords.cs
 create mode 100644 Content.Shared/_CD/Records/SharedCharacterRecordConsole.cs
 create mode 100644 Resources/Locale/en-US/_CD/admin/admin.ftl
 create mode 100644 Resources/Locale/en-US/_CD/guidebook/guides.ftl
 create mode 100644 Resources/Locale/en-US/_CD/preferences/ui/humanoid-profile-editor.ftl
 create mode 100644 Resources/Locale/en-US/_CD/records/corrections.ftl
 create mode 100644 Resources/Locale/en-US/_CD/records/editor.ftl
 create mode 100644 Resources/Locale/en-US/_CD/records/viewer.ftl
 create mode 100644 Resources/Prototypes/_CD/Guidebook/features.yml
 create mode 100644 Resources/ServerInfo/Guidebook/_CD/Records.xml

diff --git a/Content.Client/Administration/UI/Tabs/AdminTab/AdminTab.xaml b/Content.Client/Administration/UI/Tabs/AdminTab/AdminTab.xaml
index 8b68487547..b558d6114e 100644
--- a/Content.Client/Administration/UI/Tabs/AdminTab/AdminTab.xaml
+++ b/Content.Client/Administration/UI/Tabs/AdminTab/AdminTab.xaml
@@ -3,6 +3,7 @@
     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
     xmlns:cc="clr-namespace:Content.Client.Administration.UI.CustomControls"
     xmlns:at="clr-namespace:Content.Client.Administration.UI.Tabs.AdminTab"
+    xmlns:cdAdmin="clr-namespace:Content.Client._CD.Admin.UI"
     Margin="4"
     MinSize="50 50">
     <BoxContainer Orientation="Vertical">
@@ -16,6 +17,8 @@
             <cc:UICommandButton Command="callshuttle" Text="{Loc admin-player-actions-window-shuttle}" WindowType="{x:Type at:AdminShuttleWindow}"/>
             <cc:CommandButton Command="adminlogs" Text="{Loc admin-player-actions-window-admin-logs}"/>
             <cc:CommandButton Command="faxui" Text="{Loc admin-player-actions-window-admin-fax}"/>
+            <!-- CD: records purge button -->
+            <cc:UICommandButton Command="purgecharacterrecords" Text="{Loc admin-player-actions-window-cd-record-purge}" WindowType="{x:Type cdAdmin:ModifyCharacterRecords}"/>
         </GridContainer>
     </BoxContainer>
 </Control>
diff --git a/Content.Client/Humanoid/HumanoidAppearanceSystem.cs b/Content.Client/Humanoid/HumanoidAppearanceSystem.cs
index 0416f4b813..d735e264ce 100644
--- a/Content.Client/Humanoid/HumanoidAppearanceSystem.cs
+++ b/Content.Client/Humanoid/HumanoidAppearanceSystem.cs
@@ -5,6 +5,8 @@ using Content.Shared.Preferences;
 using Robust.Client.GameObjects;
 using Robust.Shared.Prototypes;
 using Robust.Shared.Utility;
+using System.Numerics; // CD - Character Records
+using Robust.Client.Console; // CD - Character Records
 
 namespace Content.Client.Humanoid;
 
@@ -30,6 +32,13 @@ public sealed class HumanoidAppearanceSystem : SharedHumanoidAppearanceSystem
         UpdateLayers(component, sprite);
         ApplyMarkingSet(component, sprite);
 
+        // Begin CD - Character Records
+        var speciesPrototype = _prototypeManager.Index<SpeciesPrototype>(component.Species);
+        var height = Math.Clamp(MathF.Round(component.Height, 2), speciesPrototype.MinHeight, speciesPrototype.MaxHeight); // should NOT be locked, at all
+
+        sprite.Scale = speciesPrototype.BaseScale * new Vector2(speciesPrototype.ScaleHeight ? height : 1f, height); // DV - CD Character Records shouldn't nuke species heights
+        // End CD - Character Records
+
         sprite[sprite.LayerMapReserveBlank(HumanoidVisualLayers.Eyes)].Color = component.EyeColor;
     }
 
@@ -199,6 +208,7 @@ public sealed class HumanoidAppearanceSystem : SharedHumanoidAppearanceSystem
         humanoid.Species = profile.Species;
         humanoid.SkinColor = profile.Appearance.SkinColor;
         humanoid.EyeColor = profile.Appearance.EyeColor;
+        humanoid.Height = profile.Height; // CD - Character Records
 
         UpdateSprite(humanoid, Comp<SpriteComponent>(uid));
     }
diff --git a/Content.Client/Lobby/UI/HumanoidProfileEditor.xaml b/Content.Client/Lobby/UI/HumanoidProfileEditor.xaml
index 703b64bce3..54c6356d68 100644
--- a/Content.Client/Lobby/UI/HumanoidProfileEditor.xaml
+++ b/Content.Client/Lobby/UI/HumanoidProfileEditor.xaml
@@ -67,6 +67,15 @@
                                     <Control HorizontalExpand="True"/>
                                     <LineEdit Name="AgeEdit" MinSize="40 0" HorizontalAlignment="Right" />
                                 </BoxContainer>
+                                <!-- Begin CD - Character Records -->
+                                <BoxContainer HorizontalExpand="True" Visible="False"> <!-- DeltaV - we haven't decided on height yet -->
+                                    <Label Text="{Loc 'humanoid-profile-editor-height-label'}" />
+                                    <Control HorizontalExpand="True" />
+                                    <Slider Name="CDHeightSlider" HorizontalAlignment="Right" SetWidth="300" MinValue="0.0" MaxValue="1.0"/>
+                                    <LineEdit HorizontalAlignment="Right" Name="CDHeight" MinSize="60 0" Text="1.0" />
+                                    <Button Name="CDHeightReset" Text="{Loc 'humanoid-profile-editor-reset-height-button'}" HorizontalAlignment="Right"/>
+                                </BoxContainer>
+                                <!-- End CD - Character Records -->
                                 <!-- Sex -->
                                 <BoxContainer HorizontalExpand="True">
                                     <Label Text="{Loc 'humanoid-profile-editor-sex-label'}" />
diff --git a/Content.Client/Lobby/UI/HumanoidProfileEditor.xaml.cs b/Content.Client/Lobby/UI/HumanoidProfileEditor.xaml.cs
index e37733ec34..ac1fcdd8b0 100644
--- a/Content.Client/Lobby/UI/HumanoidProfileEditor.xaml.cs
+++ b/Content.Client/Lobby/UI/HumanoidProfileEditor.xaml.cs
@@ -33,6 +33,11 @@ using Robust.Shared.Enums;
 using Robust.Shared.Prototypes;
 using Robust.Shared.Utility;
 using Direction = Robust.Shared.Maths.Direction;
+// Begin CD - Character Records
+using System.Globalization;
+using Content.Client._CD.Records.UI;
+using Content.Shared._CD.Records;
+// End CD - Character Records
 
 namespace Content.Client.Lobby.UI
 {
@@ -96,6 +101,12 @@ namespace Content.Client.Lobby.UI
 
         private bool _isDirty;
 
+        // Begin CD - Station Records
+        private float _defaultHeight = 1f;
+
+        private readonly RecordEditorGui _recordsTab;
+        // End CD - Station Records
+
         [ValidatePrototypeId<GuideEntryPrototype>]
         private const string DefaultSpeciesGuidebook = "Species";
 
@@ -220,6 +231,43 @@ namespace Content.Client.Lobby.UI
                 OnSkinColorOnValueChanged();
             };
 
+            // Begin CD - Character Records
+            #region CDHeight
+
+            CDHeight.OnTextChanged += args =>
+            {
+                if (Profile is null || !float.TryParse(args.Text, out var newHeight))
+                    return;
+
+                var prototype = _prototypeManager.Index<SpeciesPrototype>(Profile.Species);
+                newHeight = MathF.Round(Math.Clamp(newHeight, prototype.MinHeight, prototype.MaxHeight), 2);
+
+                // The percentage between the start and end numbers, aka "inverse lerp"
+                var sliderPercent = (newHeight - prototype.MinHeight) /
+                                    (prototype.MaxHeight - prototype.MinHeight);
+                CDHeightSlider.Value = sliderPercent;
+
+                SetProfileHeight(newHeight);
+            };
+
+            CDHeightReset.OnPressed += _ =>
+            {
+                CDHeight.SetText(_defaultHeight.ToString(CultureInfo.InvariantCulture), true);
+            };
+
+            CDHeightSlider.OnValueChanged += _ =>
+            {
+                if (Profile is null)
+                    return;
+                var prototype = _prototypeManager.Index<SpeciesPrototype>(Profile.Species);
+                var newHeight = MathF.Round(MathHelper.Lerp(prototype.MinHeight, prototype.MaxHeight, CDHeightSlider.Value), 2);
+                CDHeight.Text = newHeight.ToString(CultureInfo.InvariantCulture);
+                SetProfileHeight(newHeight);
+            };
+
+            #endregion CDHeight
+            // End CD - Character Records
+
             #region Skin
 
             Skin.OnValueChanged += _ =>
@@ -413,6 +461,16 @@ namespace Content.Client.Lobby.UI
 
             #endregion Markings
 
+            // Begin CD - Character Records
+            #region CosmaticRecords
+
+            _recordsTab = new RecordEditorGui(UpdateProfileRecords);
+            TabContainer.AddChild(_recordsTab);
+            TabContainer.SetTabTitle(TabContainer.ChildCount - 1, Loc.GetString("humanoid-profile-editor-cd-records-tab"));
+
+            #endregion CosmaticRecords
+            // End CD - Character Records
+
             RefreshFlavorText();
 
             #region Dummy
@@ -754,6 +812,11 @@ namespace Content.Client.Lobby.UI
             UpdateCMarkingsHair();
             UpdateCMarkingsFacialHair();
 
+            // Begin CD - Character Records
+            UpdateHeightControls();
+            _recordsTab.Update(profile);
+            // End CD - Character Records
+
             RefreshAntags();
             RefreshJobs();
             RefreshLoadouts();
@@ -1050,6 +1113,16 @@ namespace Content.Client.Lobby.UI
             UpdateJobPriorities();
         }
 
+        // Start CD - Character Records
+        private void UpdateProfileRecords(PlayerProvidedCharacterRecords records)
+        {
+            if (Profile is null)
+                return;
+            Profile = Profile.WithCDCharacterRecords(records);
+            IsDirty = true;
+        }
+        // End CD - Character Records
+
         private void OnFlavorTextChange(string content)
         {
             if (Profile is null)
@@ -1231,6 +1304,15 @@ namespace Content.Client.Lobby.UI
             _entManager.System<MetaDataSystem>().SetEntityName(PreviewDummy, newName);
         }
 
+        // Begin CD - Character Records
+        private void SetProfileHeight(float height)
+        {
+            Profile = Profile?.WithHeight(height);
+            SetDirty();
+            ReloadProfilePreview();
+        }
+        // End CD - Character Records
+
         private void SetSpawnPriority(SpawnPriorityPreference newSpawnPriority)
         {
             Profile = Profile?.WithSpawnPriorityPreference(newSpawnPriority);
@@ -1416,6 +1498,26 @@ namespace Content.Client.Lobby.UI
             PronounsButton.SelectId((int) Profile.Gender);
         }
 
+        // Begin CD - Character Records
+        private void UpdateHeightControls()
+        {
+            if (Profile == null)
+            {
+                return;
+            }
+
+            var species = _species.Find(x => x.ID == Profile.Species);
+            if (species != null)
+                _defaultHeight = species.DefaultHeight;
+
+            var prototype = _prototypeManager.Index<SpeciesPrototype>(Profile.Species);
+            var sliderPercent = (Profile.Height - prototype.MinHeight) /
+                                (prototype.MaxHeight - prototype.MinHeight);
+            CDHeightSlider.Value = sliderPercent;
+            CDHeight.Text = Profile.Height.ToString(CultureInfo.InvariantCulture);
+        }
+        // End CD - Character Records
+
         private void UpdateSpawnPriorityControls()
         {
             if (Profile == null)
@@ -1558,6 +1660,8 @@ namespace Content.Client.Lobby.UI
             var name = HumanoidCharacterProfile.GetName(Profile.Species, Profile.Gender);
             SetName(name);
             UpdateNameEdit();
+
+            _recordsTab.Update(Profile); // CD - Character Records
         }
 
         private async void ExportImage()
diff --git a/Content.Client/_CD/Admin/UI/ModifyCharacterRecords.xaml b/Content.Client/_CD/Admin/UI/ModifyCharacterRecords.xaml
new file mode 100644
index 0000000000..9cb3184970
--- /dev/null
+++ b/Content.Client/_CD/Admin/UI/ModifyCharacterRecords.xaml
@@ -0,0 +1,14 @@
+<DefaultWindow xmlns="https://spacestation14.io"
+               xmlns:cc="clr-namespace:Content.Client.Administration.UI.CustomControls"
+               Title="{Loc cd-actions-admin-modify-records}"
+               MinSize="300 300">
+    <BoxContainer Orientation="Vertical">
+        <LineEdit Name="EntityEdit" PlaceHolder="Entity" HorizontalExpand="True" />
+        <OptionButton Name="EntityEntryType" HorizontalExpand="True" />
+        <LineEdit Name="EntityEntryIndex" PlaceHolder="Index"/>
+        <BoxContainer Orientation="Horizontal" >
+            <cc:CommandButton Name="PurgeCommand" Text="{Loc cd-actions-admin-modify-reset}"/>
+            <cc:CommandButton Name="DelCommand" Text="{Loc cd-actions-admin-modify-del-entry}"/>
+        </BoxContainer>
+    </BoxContainer>
+</DefaultWindow>
diff --git a/Content.Client/_CD/Admin/UI/ModifyCharacterRecords.xaml.cs b/Content.Client/_CD/Admin/UI/ModifyCharacterRecords.xaml.cs
new file mode 100644
index 0000000000..9a86865099
--- /dev/null
+++ b/Content.Client/_CD/Admin/UI/ModifyCharacterRecords.xaml.cs
@@ -0,0 +1,48 @@
+using Content.Shared._CD.Records;
+using Robust.Client.AutoGenerated;
+using Robust.Client.UserInterface.CustomControls;
+using Robust.Client.UserInterface.XAML;
+
+namespace Content.Client._CD.Admin.UI;
+
+[GenerateTypedNameReferences]
+public sealed partial class ModifyCharacterRecords : DefaultWindow
+{
+    public ModifyCharacterRecords()
+    {
+        RobustXamlLoader.Load(this);
+        IoCManager.InjectDependencies(this);
+
+        foreach (var v in Enum.GetValues<CharacterRecordType>())
+        {
+            EntityEntryType.AddItem(v.ToString());
+        }
+
+        EntityEntryType.OnItemSelected += args =>
+        {
+            EntityEntryType.SelectId(args.Id);
+            UpdateCommands();
+        };
+
+        EntityEdit.OnTextChanged += _ => UpdateCommands();
+        EntityEntryIndex.OnTextChanged += _ => UpdateCommands();
+    }
+
+    private void UpdateCommands()
+    {
+        if (!int.TryParse(EntityEdit.Text, out var uid))
+        {
+            return;
+        }
+
+        if (!int.TryParse(EntityEntryIndex.Text, out var idx))
+        {
+            return;
+        }
+
+        var ty = (CharacterRecordType)EntityEntryType.SelectedId;
+
+        PurgeCommand.Command = $"purgecharacterrecords {uid}";
+        DelCommand.Command = $"delrecordentry {uid} {ty.ToString()} {idx}";
+    }
+}
diff --git a/Content.Client/_CD/Records/UI/CharacterRecordConsoleBoundUserInterface.cs b/Content.Client/_CD/Records/UI/CharacterRecordConsoleBoundUserInterface.cs
new file mode 100644
index 0000000000..4a1e9a392b
--- /dev/null
+++ b/Content.Client/_CD/Records/UI/CharacterRecordConsoleBoundUserInterface.cs
@@ -0,0 +1,75 @@
+using Content.Shared.CriminalRecords.Components;
+using Content.Shared.CriminalRecords;
+using Content.Shared.StationRecords;
+using Content.Shared._CD.Records;
+using JetBrains.Annotations;
+
+namespace Content.Client._CD.Records.UI;
+
+[UsedImplicitly]
+public sealed class CharacterRecordConsoleBoundUserInterface(EntityUid owner, Enum key) : BoundUserInterface(owner, key)
+{
+    [ViewVariables] private CharacterRecordViewer? _window;
+
+    protected override void UpdateState(BoundUserInterfaceState baseState)
+    {
+        base.UpdateState(baseState);
+        if (baseState is not CharacterRecordConsoleState state)
+            return;
+
+        if (_window?.IsSecurity() ?? false)
+        {
+            var comp = EntMan.GetComponent<CriminalRecordsConsoleComponent>(Owner);
+            _window!.SecurityWantedStatusMaxLength = comp.MaxStringLength;
+        }
+
+        _window?.UpdateState(state);
+    }
+
+    protected override void Open()
+    {
+        base.Open();
+
+        _window = new();
+        _window.OnClose += Close;
+        _window.OnListingItemSelected += meta =>
+        {
+            SendMessage(new CharacterRecordConsoleSelectMsg(meta?.CharacterRecordKey));
+
+            // If we are a security records console, we also need to inform the criminal records
+            // system of our state.
+            if (_window.IsSecurity() && meta?.StationRecordKey != null)
+            {
+                SendMessage(new SelectStationRecord(meta.Value.StationRecordKey.Value));
+                _window.SetSecurityStatusEnabled(true);
+            }
+            else
+            {
+                // If the user does not have criminal records for some reason, we should not be able
+                // to set their wanted status
+                _window.SetSecurityStatusEnabled(false);
+            }
+        };
+
+        _window.OnFiltersChanged += (ty, txt) =>
+        {
+            SendMessage(txt == null
+                ? new CharacterRecordsConsoleFilterMsg(null)
+                : new CharacterRecordsConsoleFilterMsg(new StationRecordsFilter(ty, txt)));
+        };
+
+        _window.OnSetSecurityStatus += (status, reason) =>
+        {
+            SendMessage(new CriminalRecordChangeStatus(status, reason));
+        };
+
+        _window.OpenCentered();
+    }
+
+    protected override void Dispose(bool disposing)
+    {
+        base.Dispose(disposing);
+
+        _window?.Close();
+    }
+}
diff --git a/Content.Client/_CD/Records/UI/CharacterRecordViewer.xaml b/Content.Client/_CD/Records/UI/CharacterRecordViewer.xaml
new file mode 100644
index 0000000000..a952accd81
--- /dev/null
+++ b/Content.Client/_CD/Records/UI/CharacterRecordViewer.xaml
@@ -0,0 +1,117 @@
+<controls:FancyWindow xmlns="https://spacestation14.io"
+                      xmlns:controls="clr-namespace:Content.Client.UserInterface.Controls"
+                      xmlns:records="clr-namespace:Content.Client._CD.Records.UI"
+                      MinSize="850 750"
+                      SetSize="850 750" >
+    <BoxContainer Orientation="Vertical">
+        <!-- Search bar -->
+        <BoxContainer Margin="5 5 5 10" HorizontalExpand="true" VerticalAlignment="Center">
+            <OptionButton Name="RecordFilterType" MinWidth="200" Margin="0 0 10 0" Visible="False"/>
+            <!-- Yes, we do steal some localizations, should be fine -->
+            <LineEdit Name="RecordFiltersValue"
+                PlaceHolder="{Loc 'general-station-record-for-filter-line-placeholder'}" HorizontalExpand="True"/>
+            <Button Name="RecordFilters" Text="{Loc 'general-station-record-console-search-records'}"/>
+            <Button Name="RecordFiltersReset" Text="{Loc 'general-station-record-console-reset-filters'}"/>
+        </BoxContainer>
+        <BoxContainer VerticalExpand="True">
+            <!-- Character listing -->
+            <BoxContainer Orientation="Vertical" Margin="5" MinWidth="250" MaxWidth="250">
+                <Label Name="CharacterListingStatus" Visible="False" />
+                <ScrollContainer VerticalExpand="True">
+                    <ItemList Name="CharacterListing" />
+                </ScrollContainer>
+            </BoxContainer>
+            <!-- Record box -->
+            <BoxContainer Orientation="Vertical" HorizontalExpand="True" Margin="5 5 10 10">
+                <Label Name="RecordContainerStatus" Visible="False" Text="{Loc 'cd-record-viewer-no-record-selected'}"/>
+                <BoxContainer Name="RecordContainer" Orientation="Vertical" Visible="False" >
+                    <BoxContainer Orientation="Vertical" HorizontalExpand="True">
+                        <!-- Common -->
+                        <BoxContainer Orientation="Vertical" HorizontalExpand="True">
+                            <Label Name="RecordContainerName" StyleClasses="LabelBig" />
+                            <BoxContainer Orientation="Horizontal" HorizontalExpand="True">
+                                <Label Text="{Loc 'cd-character-records-viewer-record-age'}"/>
+                                <Control HorizontalExpand="True" />
+                                <Label Name="RecordContainerAge" Align="Right" />
+                            </BoxContainer>
+                            <BoxContainer Orientation="Horizontal" HorizontalExpand="True">
+                                <Label Text="{Loc 'cd-character-records-viewer-record-job'}"/>
+                                <Control HorizontalExpand="True" />
+                                <Label Name="RecordContainerJob" Align="Right" />
+                            </BoxContainer>
+                            <BoxContainer Orientation="Horizontal" HorizontalExpand="True">
+                                <Label Text="{Loc 'cd-character-records-viewer-record-gender'}"/>
+                                <Control HorizontalExpand="True" />
+                                <Label Name="RecordContainerGender" Align="Right" />
+                            </BoxContainer>
+                            <BoxContainer Orientation="Horizontal" HorizontalExpand="True">
+                                <Label Text="{Loc 'cd-character-records-viewer-record-species'}"/>
+                                <Control HorizontalExpand="True" />
+                                <Label Name="RecordContainerSpecies" Align="Right" />
+                            </BoxContainer>
+                            <BoxContainer Orientation="Horizontal" HorizontalExpand="True">
+                                <Label Text="{Loc 'humanoid-profile-editor-cd-records-height'}"/>
+                                <Control HorizontalExpand="True" />
+                                <Label Name="RecordContainerHeight" Align="Right" />
+                            </BoxContainer>
+                            <BoxContainer Orientation="Horizontal" HorizontalExpand="True">
+                                <Label Text="{Loc 'humanoid-profile-editor-cd-records-weight'}"/>
+                                <Control HorizontalExpand="True" />
+                                <Label Name="RecordContainerWeight" Align="Right"/>
+                            </BoxContainer>
+                            <records:RecordLongItemDisplay Name="RecordContainerContactName" Title="{Loc 'humanoid-profile-editor-cd-records-contact-name'}"/>
+                        </BoxContainer>
+                        <!-- Employment -->
+                        <BoxContainer Name="RecordContainerEmployment" Orientation="Vertical" HorizontalExpand="True" Visible="False" >
+                            <BoxContainer Orientation="Horizontal" HorizontalExpand="True">
+                                <Label Text="{Loc 'humanoid-profile-editor-cd-records-work-authorization'}"/>
+                                <Control HorizontalExpand="True" />
+                                <Label Name="RecordContainerWorkAuth" Align="Right" />
+                            </BoxContainer>
+                        </BoxContainer>
+                        <!-- Medical -->
+                        <BoxContainer Name="RecordContainerMedical" Orientation="Vertical" HorizontalExpand="True" Visible="False" >
+                            <records:RecordLongItemDisplay Name="RecordContainerAllergies" Title="{Loc 'humanoid-profile-editor-cd-records-allergies'}"/>
+                            <records:RecordLongItemDisplay Name="RecordContainerDrugAllergies" Title="{Loc 'humanoid-profile-editor-cd-records-drug-allergies'}"/>
+                            <records:RecordLongItemDisplay Name="RecordContainerPostmortem" Title="{Loc 'humanoid-profile-editor-cd-records-postmortem'}"/>
+                            <BoxContainer Orientation="Horizontal" HorizontalExpand="True">
+                                <Label Text="{Loc 'cd-character-records-viewer-record-med-sex'}"/>
+                                <Control HorizontalExpand="True" />
+                                <Label Name="RecordContainerSex" Align="Right" />
+                            </BoxContainer>
+                        </BoxContainer>
+                        <!-- Security -->
+                        <BoxContainer Name="RecordContainerSecurity" Orientation="Vertical" HorizontalExpand="True" Visible="False" >
+                            <records:RecordLongItemDisplay Name="RecordContainerIdentFeatures" Title="{Loc 'humanoid-profile-editor-cd-records-identifying-features'}"/>
+                            <BoxContainer Orientation="Horizontal" HorizontalExpand="True">
+                                <Label Text="{Loc 'cd-character-records-viewer-record-sec-fingerprint'}"/>
+                                <Control HorizontalExpand="True" />
+                                <Label Name="RecordContainerFingerprint" Align="Right" />
+                            </BoxContainer>
+                            <BoxContainer Orientation="Horizontal" HorizontalExpand="True">
+                                <Label Text="{Loc 'cd-character-records-viewer-record-sec-dna'}"/>
+                                <Control HorizontalExpand="True" />
+                                <Label Name="RecordContainerDNA" Align="Right" />
+                            </BoxContainer>
+                            <BoxContainer Orientation="Horizontal" Margin="5 5 5 5">
+                                <Label Text="{Loc 'criminal-records-console-status'}" FontColorOverride="DarkGray"/>
+                                <OptionButton Name="StatusOptionButton"/>
+                                <Control MinWidth="5"/>
+                                <Label Name="RecordContainerWantedReason" Visible="False" />
+                            </BoxContainer>
+                        </BoxContainer>
+                    </BoxContainer>
+                    <!-- Entry viewer -->
+                    <BoxContainer Orientation="Vertical" HorizontalExpand="True" Margin="10" SeparationOverride="5">
+                        <ItemList Name="RecordEntryList" HorizontalExpand="True" MinHeight="200" />
+                        <BoxContainer Orientation="Horizontal">
+                            <Button Name="RecordEntryViewButton" Text="{Loc 'cd-character-records-viewer-view-entry'}"/>
+                            <!-- Admin console entry type selector -->
+                            <OptionButton Name="RecordEntryViewType" />
+                        </BoxContainer>
+                    </BoxContainer>
+                </BoxContainer>
+            </BoxContainer>
+        </BoxContainer>
+    </BoxContainer>
+</controls:FancyWindow>
diff --git a/Content.Client/_CD/Records/UI/CharacterRecordViewer.xaml.cs b/Content.Client/_CD/Records/UI/CharacterRecordViewer.xaml.cs
new file mode 100644
index 0000000000..76cc56b2ed
--- /dev/null
+++ b/Content.Client/_CD/Records/UI/CharacterRecordViewer.xaml.cs
@@ -0,0 +1,450 @@
+using Content.Client.UserInterface.Controls;
+using Content.Shared.Administration;
+using Content.Shared.Security;
+using Content.Shared.StationRecords;
+using Content.Shared._CD.Records;
+using Robust.Client.AutoGenerated;
+using Robust.Client.UserInterface.XAML;
+using System.Linq;
+
+namespace Content.Client._CD.Records.UI;
+
+[GenerateTypedNameReferences]
+public sealed partial class CharacterRecordViewer : FancyWindow
+{
+    public struct CharacterListMetadata
+    {
+        public uint CharacterRecordKey;
+        public uint? StationRecordKey;
+    }
+
+    public static readonly Color BackgroundColor = Color.FromHex("#25252a"); // Dark grey
+    public static readonly Color ContentPanelColor = Color.FromHex("#1a1a1a"); // Darker grey for content areas
+    public static readonly Color BorderColor = Color.FromHex("#404040"); // Light grey border
+    public static readonly Color ErrorColor = Color.FromHex("#ff0000"); // Red for validation errors
+
+    public event Action<CharacterListMetadata?>? OnListingItemSelected;
+    public event Action<StationRecordFilterType, string?>? OnFiltersChanged;
+
+    private bool _isPopulating;
+    private StationRecordFilterType _filterType;
+
+    private RecordConsoleType? _type;
+
+    private readonly RecordEntryViewPopup _entryView = new();
+    private List<PlayerProvidedCharacterRecords.RecordEntry>? _entries;
+
+    private DialogWindow? _wantedReasonDialog;
+
+    /// <summary>
+    /// The key to the record of the currently selected item in the listing.
+    /// </summary>
+    private uint? _selectedListingKey;
+
+    /// <summary>
+    /// The key to the record that is currently visible.
+    /// </summary>
+    /// <remarks>
+    /// This may differ from <see cref="_selectedListingKey"/> because this contents has not been updated yet to reflect the new selection.
+    /// </remarks>
+    private uint? _openRecordKey;
+    public event Action<SecurityStatus, string?>? OnSetSecurityStatus;
+
+    public uint? SecurityWantedStatusMaxLength;
+
+    public CharacterRecordViewer()
+    {
+        RobustXamlLoader.Load(this);
+
+        // There is no reason why we can't just steal the StationRecordFilter class.
+        // If wizden adds a new kind of filtering we want to replicate it here.
+        foreach (var item in Enum.GetValues<StationRecordFilterType>())
+        {
+            RecordFilterType.AddItem(GetTypeFilterLocals(item), (int)item);
+        }
+
+        // Again, if wizden changes something about Criminal Records, we want to replicate the
+        // functionality here.
+        foreach (var status in Enum.GetValues<SecurityStatus>())
+        {
+            var name = Loc.GetString($"criminal-records-status-{status.ToString().ToLower()}");
+            StatusOptionButton.AddItem(name, (int)status);
+        }
+
+        CharacterListing.OnItemSelected += _ =>
+        {
+            if (!CharacterListing.GetSelected().Any())
+                return;
+            var selected = CharacterListing.GetSelected().First();
+            var meta = (CharacterListMetadata)selected.Metadata!;
+            _selectedListingKey = meta.CharacterRecordKey;
+            if (!_isPopulating)
+                OnListingItemSelected?.Invoke(meta);
+        };
+
+        CharacterListing.OnItemDeselected += _ =>
+        {
+            // When we populate the records, we clear the contents of the listing.
+            // This could cause a deselection but we don't want to really deselect because it would
+            // interrupt what the player is doing.
+            if (!_isPopulating)
+                OnListingItemSelected?.Invoke(null);
+            _selectedListingKey = null;
+        };
+
+        RecordFilters.OnPressed += _ =>
+        {
+            OnFiltersChanged?.Invoke(_filterType, RecordFiltersValue.Text);
+        };
+
+        RecordFiltersReset.OnPressed += _ =>
+        {
+            OnFiltersChanged?.Invoke(StationRecordFilterType.Name, null);
+            RecordFiltersValue.Clear();
+        };
+
+        RecordFiltersValue.OnTextEntered += text =>
+        {
+            OnFiltersChanged?.Invoke(_filterType, text.Text);
+        };
+
+        RecordFilterType.OnItemSelected += eventArgs =>
+        {
+            var type = (StationRecordFilterType)eventArgs.Id;
+            _filterType = type;
+            RecordFilterType.SelectId(eventArgs.Id);
+        };
+
+        RecordEntryViewButton.OnPressed += _ =>
+        {
+            if (_entries == null || !RecordEntryList.GetSelected().Any())
+                return;
+            var idx = RecordEntryList.IndexOf(RecordEntryList.GetSelected().First());
+            _entryView.SetContents(_entries[idx]);
+            _entryView.Open();
+        };
+
+        StatusOptionButton.OnItemSelected += args =>
+        {
+            var status = (SecurityStatus)args.Id;
+            // This should reflect SetStatus in CriminalRecordsConsoleWindow.xaml.cs
+            if (status == SecurityStatus.Wanted || status == SecurityStatus.Suspected)
+                SetStatusWithReason(status);
+            else
+                OnSetSecurityStatus?.Invoke(status, null);
+        };
+
+        OnClose += () => _entryView.Close();
+
+        // Admin console entry type selector
+        RecordEntryViewType.AddItem(Loc.GetString("department-Security"));
+        RecordEntryViewType.AddItem(Loc.GetString("department-Medical"));
+        RecordEntryViewType.AddItem(Loc.GetString("humanoid-profile-editor-cd-records-employment"));
+        RecordEntryViewType.OnItemSelected += args =>
+        {
+            if (args.Id == RecordEntryViewType.SelectedId)
+                return;
+            RecordEntryViewType.SelectId(args.Id);
+            // This is a hack to get the server to send us another packet with the new entries
+            OnFiltersChanged?.Invoke(_filterType, RecordFiltersValue.Text);
+        };
+    }
+
+    // If we are using wizden's class we might as well use their localization.
+    private string GetTypeFilterLocals(StationRecordFilterType type)
+    {
+        return Loc.GetString($"general-station-record-{type.ToString().ToLower()}-filter");
+    }
+
+    /// <summary>
+    /// Select the record in the listing for the given key.
+    /// </summary>
+    /// <param name="key">The index of the record in the dictionary</param>
+    private void SelectRecordKey(uint? key)
+    {
+        if (_selectedListingKey == key)
+            return;
+        _selectedListingKey = key;
+
+        _isPopulating = true;
+
+        CharacterListing.ClearSelected();
+
+        // I wish there was a better way of doing this
+        if (key != null)
+        {
+            foreach (var item in CharacterListing)
+            {
+                if (((CharacterListMetadata) item.Metadata!).CharacterRecordKey == key)
+                {
+                    item.Selected = true;
+                    break;
+                }
+            }
+        }
+
+        _isPopulating = false;
+    }
+
+    private bool CharacterListNeedsRepopulating(IReadOnlyDictionary<uint, CharacterRecordConsoleState.CharacterInfo> newKeys)
+    {
+        var newCount = newKeys.Count;
+        if (newCount != CharacterListing.Count)
+            return true;
+
+        // Given that there is the same number of keys in the dictionary as in items in the listing, they are not equal
+        // if and only if there exists a key in the listing that is not in the dictionary
+        foreach (var item in CharacterListing)
+        {
+            var key = ((CharacterListMetadata)item.Metadata!).CharacterRecordKey;
+            if (!newKeys.ContainsKey(key))
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    public void UpdateState(CharacterRecordConsoleState state)
+    {
+        #region Visibility
+
+        RecordEntryViewType.Visible = false;
+        _type = state.ConsoleType;
+
+        // Disable listing if we don't have one selected
+        if (state.CharacterList == null)
+        {
+            CharacterListingStatus.Visible = true;
+            CharacterListing.Visible = false;
+            CharacterListingStatus.Text = Loc.GetString("cd-record-viewer-empty-state");
+            RecordContainer.Visible = false;
+            RecordContainerStatus.Visible = false;
+            return;
+        }
+
+        CharacterListingStatus.Visible = false;
+        CharacterListing.Visible = true;
+
+        // Enable extended filtering only for admin and security consoles
+        switch (_type)
+        {
+            case RecordConsoleType.Employment:
+                RecordFilterType.Visible = false;
+                RecordFilterType.SelectId((int)StationRecordFilterType.Name);
+
+                Title = Loc.GetString("cd-character-records-viewer-title-employ");
+                break;
+            case RecordConsoleType.Medical:
+                RecordFilterType.Visible = false;
+                RecordFilterType.SelectId((int)StationRecordFilterType.Name);
+
+                Title = Loc.GetString("cd-character-records-viewer-title-med");
+                break;
+            case RecordConsoleType.Security:
+                RecordFilterType.Visible = true;
+
+                Title = Loc.GetString("cd-character-records-viewer-title-sec");
+                break;
+            case RecordConsoleType.Admin:
+                RecordFilterType.Visible = true;
+                Title = "Admin records console";
+                RecordEntryViewType.Visible = true;
+
+                break;
+        }
+
+        #endregion
+
+        #region PopulateListing
+
+        if (state.Filter != null)
+        {
+            RecordFiltersValue.SetText(state.Filter.Value);
+            RecordFilterType.SelectId((int) state.Filter.Type);
+        }
+
+        if (CharacterListNeedsRepopulating(state.CharacterList))
+        {
+            _isPopulating = true;
+
+            CharacterListing.Clear();
+
+            // Add the records to the listing in a sorted order. There is probably are faster way of doing this, but
+            // this is not really a hot code path.
+            state.CharacterList
+                // The items in this tuple are as follows: (name of character, CharacterListMetadata)
+                .Select(r
+                    => (CharacterName: r.Value.CharacterDisplayName, new CharacterListMetadata() { CharacterRecordKey = r.Key, StationRecordKey = r.Value.StationRecordKey}))
+                .OrderBy(r => r.Item1)
+                .ToList()
+                .ForEach(r => CharacterListing.AddItem(r.Item1, metadata: r.Item2));
+
+            _isPopulating = false;
+        }
+
+        SelectRecordKey(state.SelectedIndex);
+
+        #endregion
+
+        #region FillRecordContainer
+
+        // Enable container if we have a record selected
+        if (state.SelectedRecord == null)
+        {
+            RecordContainerStatus.Visible = true;
+            RecordContainer.Visible = false;
+            return;
+        }
+
+        RecordContainerStatus.Visible = false;
+        RecordContainer.Visible = true;
+
+        // Do not needlessly reload the record if not needed. This is mainly done to prevent a bug in the admin record viewer.
+        if (state.SelectedIndex == _openRecordKey)
+            return;
+        _openRecordKey = state.SelectedIndex;
+
+        var record = state.SelectedRecord!;
+        var cr = record.PRecords;
+
+        // Basic info
+        RecordContainerName.Text = record.Name;
+        RecordContainerAge.Text = record.Age.ToString();
+        RecordContainerJob.Text = record.JobTitle; /* At some point in the future we might want to display the icon */
+        RecordContainerGender.Text = record.Gender.ToString();
+        RecordContainerSpecies.Text = record.Species;
+        RecordContainerHeight.Text = cr.Height + " " + UnitConversion.GetImperialDisplayLength(cr.Height);
+        RecordContainerWeight.Text = cr.Weight + " " + UnitConversion.GetImperialDisplayMass(cr.Weight);
+        RecordContainerContactName.SetValue(cr.EmergencyContactName);
+
+        RecordContainerEmployment.Visible = false;
+        RecordContainerMedical.Visible = false;
+        RecordContainerSecurity.Visible = false;
+
+        switch (_type)
+        {
+            case RecordConsoleType.Employment:
+                SetEntries(cr.EmploymentEntries);
+                UpdateRecordBoxEmployment(record);
+                break;
+            case RecordConsoleType.Medical:
+                SetEntries(cr.MedicalEntries);
+                UpdateRecordBoxMedical(record);
+                break;
+            case RecordConsoleType.Security:
+                SetEntries(cr.SecurityEntries);
+                UpdateRecordBoxSecurity(record, state.SelectedSecurityStatus);
+                break;
+            case RecordConsoleType.Admin:
+                UpdateRecordBoxEmployment(record);
+                UpdateRecordBoxMedical(record);
+                UpdateRecordBoxSecurity(record, state.SelectedSecurityStatus);
+                switch ((RecordConsoleType) RecordEntryViewType.SelectedId)
+                {
+                case RecordConsoleType.Employment:
+                    SetEntries(cr.EmploymentEntries, true);
+                    break;
+                case RecordConsoleType.Medical:
+                    SetEntries(cr.MedicalEntries, true);
+                    break;
+                case RecordConsoleType.Security:
+                    SetEntries(cr.SecurityEntries, true);
+                    break;
+                }
+                break;
+        }
+
+        #endregion
+
+    }
+
+    private void SetEntries(List<PlayerProvidedCharacterRecords.RecordEntry> entries, bool addIndex = false)
+    {
+        _entries = entries;
+        RecordEntryList.Clear();
+        var i = 0;
+        foreach (var entry in entries)
+        {
+            RecordEntryList.AddItem(addIndex ? $"({i.ToString()}) " + entry.Title : entry.Title);
+            ++i;
+        }
+    }
+
+    private void UpdateRecordBoxEmployment(FullCharacterRecords record)
+    {
+        RecordContainerEmployment.Visible = true;
+        RecordContainerWorkAuth.Text = record.PRecords.HasWorkAuthorization ? "yes" : "no";
+    }
+
+    private void UpdateRecordBoxMedical(FullCharacterRecords record)
+    {
+        RecordContainerMedical.Visible = true;
+        var cr = record.PRecords;
+        RecordContainerMedical.Visible = true;
+        RecordContainerAllergies.SetValue(cr.Allergies);
+        RecordContainerDrugAllergies.SetValue(cr.DrugAllergies);
+        RecordContainerPostmortem.SetValue(cr.PostmortemInstructions);
+        RecordContainerSex.Text = record.Sex.ToString();
+    }
+
+    private void UpdateRecordBoxSecurity(FullCharacterRecords record, (SecurityStatus, string?)? criminal)
+    {
+        RecordContainerSecurity.Visible = true;
+        RecordContainerIdentFeatures.SetValue(record.PRecords.IdentifyingFeatures);
+        RecordContainerFingerprint.Text = record.Fingerprint ?? Loc.GetString("cd-character-records-viewer-unknown");
+        RecordContainerDNA.Text = record.DNA ?? Loc.GetString("cd-character-records-viewer-unknown");
+
+        RecordContainerWantedReason.Visible = false;
+        if (criminal != null)
+        {
+            var (stat, reason) = criminal.Value;
+            StatusOptionButton.Select((int)stat);
+            RecordContainerWantedReason.Text = reason;
+            RecordContainerWantedReason.Visible = reason != null;
+        }
+    }
+
+    // This is copied almost verbatim from CriminalRecordsConsoleWindow.xaml.cs
+    private void SetStatusWithReason(SecurityStatus status)
+    {
+        if (_wantedReasonDialog != null)
+        {
+            _wantedReasonDialog.MoveToFront();
+            return;
+        }
+
+        const string field = "reason";
+        var title = Loc.GetString("criminal-records-status-" + status.ToString().ToLower());
+        var placeholder = Loc.GetString("cd-character-records-viewer-setwanted-placeholder");
+        var prompt = Loc.GetString("criminal-records-console-reason");
+        var entry = new QuickDialogEntry(field, QuickDialogEntryType.LongText, prompt, placeholder);
+        var entries = new List<QuickDialogEntry>() { entry };
+        _wantedReasonDialog = new DialogWindow(title, entries);
+
+        _wantedReasonDialog.OnConfirmed += responses =>
+        {
+            var reason = responses[field];
+            if (reason.Length < 1 || reason.Length > SecurityWantedStatusMaxLength)
+                return;
+
+            OnSetSecurityStatus?.Invoke(status, reason);
+        };
+
+        _wantedReasonDialog.OnClose += () => { _wantedReasonDialog = null; };
+    }
+    public bool IsSecurity()
+    {
+        return _type == RecordConsoleType.Security || _type == RecordConsoleType.Admin;
+    }
+
+    public void SetSecurityStatusEnabled(bool setting)
+    {
+        for (var i = 0; i < StatusOptionButton.ItemCount; ++i)
+        {
+            StatusOptionButton.SetItemDisabled(i, !setting);
+        }
+    }
+}
+
diff --git a/Content.Client/_CD/Records/UI/RecordEditorEntrySelector.xaml b/Content.Client/_CD/Records/UI/RecordEditorEntrySelector.xaml
new file mode 100644
index 0000000000..328e36d0b8
--- /dev/null
+++ b/Content.Client/_CD/Records/UI/RecordEditorEntrySelector.xaml
@@ -0,0 +1,14 @@
+<Control xmlns="https://spacestation14.io">
+    <BoxContainer Orientation="Vertical" HorizontalExpand="True" VerticalExpand="True">
+        <ItemList Name="EntrySelector" HorizontalExpand="True" VerticalExpand="True" MinSize="300 200" />
+        <BoxContainer Orientation="Horizontal">
+            <Button Name="AddButton" StyleClasses="OpenBoth" Text="{Loc 'humanoid-profile-editor-cd-records-add-entry'}" />
+            <Button Name="EditButton" StyleClasses="OpenBoth" Text="{Loc 'humanoid-profile-editor-cd-records-edit-entry'}" />
+            <Button Name="ViewButton" StyleClasses="OpenBoth" Text="{Loc 'humanoid-profile-editor-cd-records-view-entry'}" />
+            <Button Name="RemoveButton" StyleClasses="OpenLeft" Text="{Loc 'humanoid-profile-editor-cd-records-remove-entry'}" />
+            <Control HorizontalExpand="True" />
+            <Button Name="UpButton" HorizontalAlignment="Right" StyleClasses="OpenRight" Text="{Loc 'humanoid-profile-editor-cd-records-up'}" />
+            <Button Name="DownButton" HorizontalAlignment="Right" StyleClasses="OpenBoth" Text="{Loc 'humanoid-profile-editor-cd-records-down'}" />
+        </BoxContainer>
+    </BoxContainer>
+</Control>
diff --git a/Content.Client/_CD/Records/UI/RecordEditorEntrySelector.xaml.cs b/Content.Client/_CD/Records/UI/RecordEditorEntrySelector.xaml.cs
new file mode 100644
index 0000000000..5bc045c5bc
--- /dev/null
+++ b/Content.Client/_CD/Records/UI/RecordEditorEntrySelector.xaml.cs
@@ -0,0 +1,135 @@
+using Content.Shared._CD.Records;
+using Robust.Client.AutoGenerated;
+using Robust.Client.UserInterface.XAML;
+using Robust.Client.UserInterface;
+using System.Linq;
+
+namespace Content.Client._CD.Records.UI;
+
+/// <summary>
+/// The box that contains the list of entities in the record editor. We create one for each record type
+/// </summary>
+[GenerateTypedNameReferences]
+public sealed partial class RecordEditorEntrySelector : Control
+{
+    private List<PlayerProvidedCharacterRecords.RecordEntry> _entries = new();
+
+    public event Action<RecordEditorEntryUpdateArgs>? OnUpdateEntries;
+
+    private readonly RecordEntryEditPopup _editPopup = new();
+    private readonly RecordEntryViewPopup _entryViewPopup = new();
+    private int _editIdx;
+
+    public RecordEditorEntrySelector()
+    {
+        RobustXamlLoader.Load(this);
+
+        AddButton.OnPressed += _ =>
+        {
+            _editIdx = _entries.Count;
+            _editPopup.SetContents(new PlayerProvidedCharacterRecords.RecordEntry("", "", ""));
+            _editPopup.Open();
+        };
+
+        EditButton.OnPressed += _ =>
+        {
+            if (!EntrySelector.GetSelected().Any())
+                return;
+            _editIdx = EntrySelector.IndexOf(EntrySelector.GetSelected().First());
+            _editPopup.SetContents(_entries[_editIdx]);
+            _editPopup.Open();
+        };
+
+        ViewButton.OnPressed += _ =>
+        {
+            if (!EntrySelector.GetSelected().Any())
+                return;
+            var idx = EntrySelector.IndexOf(EntrySelector.GetSelected().First());
+            _entryViewPopup.SetContents(_entries[idx]);
+            _entryViewPopup.Open();
+        };
+
+        RemoveButton.OnPressed += _ =>
+        {
+            if (!EntrySelector.GetSelected().Any())
+                return;
+            // Remove the entry, being careful to set the index correctly
+            var idx = EntrySelector.IndexOf(EntrySelector.GetSelected().First());
+            EntrySelector.RemoveAt(idx);
+            _entries.RemoveAt(idx);
+            if (idx == _editIdx)
+                _editPopup.Close();
+            _editIdx--;
+            OnUpdateEntries?.Invoke(new RecordEditorEntryUpdateArgs(_entries));
+        };
+
+        UpButton.OnPressed += _ =>
+        {
+            if (!EntrySelector.GetSelected().Any())
+                return;
+            var idx = EntrySelector.IndexOf(EntrySelector.GetSelected().First());
+            if (idx < 1)
+                return;
+            (_entries[idx], _entries[idx - 1]) = (_entries[idx - 1], _entries[idx]);
+            (EntrySelector[idx], EntrySelector[idx - 1]) = (EntrySelector[idx - 1], EntrySelector[idx]);
+            OnUpdateEntries?.Invoke(new RecordEditorEntryUpdateArgs(_entries));
+        };
+
+        DownButton.OnPressed += _ =>
+        {
+            if (!EntrySelector.GetSelected().Any())
+                return;
+            var idx = EntrySelector.IndexOf(EntrySelector.GetSelected().First());
+            if (idx >= EntrySelector.Count - 1)
+                return;
+            (_entries[idx], _entries[idx + 1]) = (_entries[idx + 1], _entries[idx]);
+            (EntrySelector[idx], EntrySelector[idx + 1]) = (EntrySelector[idx + 1], EntrySelector[idx]);
+            OnUpdateEntries?.Invoke(new RecordEditorEntryUpdateArgs(_entries));
+        };
+
+        _editPopup.SaveButton.OnPressed += _ =>
+        {
+            if (_editIdx >= _entries.Count)
+            {
+                var rec = _editPopup.GetContents();
+                _entries.Add(rec);
+                EntrySelector.AddItem(rec.Title);
+            }
+            else
+            {
+                _entries[_editIdx] = _editPopup.GetContents();
+                EntrySelector[_editIdx].Text = _entries[_editIdx].Title;
+            }
+            OnUpdateEntries?.Invoke(new RecordEditorEntryUpdateArgs(_entries));
+        };
+        OnVisibilityChanged += _ =>
+        {
+            _editPopup.Close();
+        };
+    }
+
+    public void UpdateContents(List<PlayerProvidedCharacterRecords.RecordEntry> entries)
+    {
+        _entries = entries;
+        RefreshSelector();
+    }
+
+    private void RefreshSelector()
+    {
+        EntrySelector.Clear();
+        foreach (var entry in _entries)
+        {
+            EntrySelector.AddItem(entry.Title);
+        }
+    }
+
+    public sealed class RecordEditorEntryUpdateArgs
+    {
+        public List<PlayerProvidedCharacterRecords.RecordEntry> Entries { get; private set; }
+
+        public RecordEditorEntryUpdateArgs(List<PlayerProvidedCharacterRecords.RecordEntry> entries)
+        {
+            Entries = entries;
+        }
+    }
+}
diff --git a/Content.Client/_CD/Records/UI/RecordEditorGui.xaml b/Content.Client/_CD/Records/UI/RecordEditorGui.xaml
new file mode 100644
index 0000000000..ef1b6e2135
--- /dev/null
+++ b/Content.Client/_CD/Records/UI/RecordEditorGui.xaml
@@ -0,0 +1,68 @@
+<Control xmlns="https://spacestation14.io"
+         xmlns:cdrecords="clr-namespace:Content.Client._CD.Records.UI">
+    <BoxContainer Orientation="Vertical">
+         <ScrollContainer VerticalExpand="True">
+             <BoxContainer Orientation="Vertical" HorizontalExpand="True" Margin="10">
+                 <!-- Height, Weight -->
+                 <GridContainer Columns="2">
+                     <BoxContainer HorizontalExpand="True" SeparationOverride="2">
+                         <Label Text="{Loc 'humanoid-profile-editor-cd-records-height'}" />
+                         <Control HorizontalExpand="True" MinSize="5 0" />
+                         <LineEdit Name="HeightEdit" HorizontalAlignment="Right" MinSize="60 0" />
+                         <Label Name="HeightImperialLabel" MinWidth="60" />
+                     </BoxContainer>
+                     <BoxContainer HorizontalExpand="True" SeparationOverride="2">
+                         <Label Text="{Loc 'humanoid-profile-editor-cd-records-weight'}" />
+                         <Control HorizontalExpand="True" MinSize="5 0" />
+                         <LineEdit Name="WeightEdit" HorizontalAlignment="Right" MinSize="60 0" />
+                         <Label Name="WeightImperialLabel" MinWidth="70"/>
+                     </BoxContainer>
+                 </GridContainer>
+                 <!-- Emergency Contact -->
+                 <BoxContainer Orientation="Horizontal">
+                     <Label Text="{Loc 'humanoid-profile-editor-cd-records-contact-name'}" />
+                     <Control HorizontalExpand="True" />
+                     <LineEdit Name="ContactNameEdit" HorizontalAlignment="Right" MinSize="350 0"/>
+                 </BoxContainer>
+                 <Control MinSize="0 20"/>
+                 <!-- Employment stuff -->
+                 <BoxContainer HorizontalExpand="True">
+                     <Label Text="{Loc 'humanoid-profile-editor-cd-records-work-authorization'}" />
+                     <Control HorizontalExpand="True" MinSize="5 0" />
+                     <CheckBox Name="WorkAuthCheckBox" HorizontalAlignment="Right"/>
+                 </BoxContainer>
+                 <Control MinSize="0 20"/>
+                 <!-- Security stuff -->
+                 <BoxContainer Orientation="Horizontal">
+                     <Label Text="{Loc 'humanoid-profile-editor-cd-records-identifying-features'}" />
+                     <Control HorizontalExpand="True" />
+                     <LineEdit Name="IdentifyingFeaturesEdit" HorizontalAlignment="Right" MinSize="350 0"/>
+                 </BoxContainer>
+                 <Control MinSize="0 20"/>
+                 <!-- Medical stuff -->
+                 <BoxContainer Orientation="Horizontal">
+                     <Label Text="{Loc 'humanoid-profile-editor-cd-records-allergies'}" />
+                     <Control HorizontalExpand="True" />
+                     <LineEdit Name="AllergiesEdit" HorizontalAlignment="Right" MinSize="350 0"/>
+                 </BoxContainer>
+                 <BoxContainer Orientation="Horizontal">
+                     <Label Text="{Loc 'humanoid-profile-editor-cd-records-drug-allergies'}" />
+                     <Control HorizontalExpand="True" />
+                     <LineEdit Name="DrugAllergiesEdit" HorizontalAlignment="Right" MinSize="350 0"/>
+                 </BoxContainer>
+                 <BoxContainer Orientation="Horizontal">
+                     <Label Text="{Loc 'humanoid-profile-editor-cd-records-postmortem'}" />
+                     <Control HorizontalExpand="True" />
+                     <LineEdit Name="PostmortemEdit" HorizontalAlignment="Right" MinSize="350 0"/>
+                 </BoxContainer>
+                 <Control MinSize="0 20"/>
+                 <!-- Entry editor -->
+                 <TabContainer Name="EntryEditorTabs" VerticalExpand="True" HorizontalExpand="True" Margin="10">
+                     <cdrecords:RecordEditorEntrySelector Name="EmploymentEntrySelector"/>
+                     <cdrecords:RecordEditorEntrySelector Name="MedicalEntrySelector"/>
+                     <cdrecords:RecordEditorEntrySelector Name="SecurityEntrySelector"/>
+                 </TabContainer>
+             </BoxContainer>
+         </ScrollContainer>
+    </BoxContainer>
+</Control>
diff --git a/Content.Client/_CD/Records/UI/RecordEditorGui.xaml.cs b/Content.Client/_CD/Records/UI/RecordEditorGui.xaml.cs
new file mode 100644
index 0000000000..f360a20623
--- /dev/null
+++ b/Content.Client/_CD/Records/UI/RecordEditorGui.xaml.cs
@@ -0,0 +1,155 @@
+using Content.Shared.Preferences;
+using Content.Shared._CD.Records;
+using Robust.Client.AutoGenerated;
+using Robust.Client.UserInterface.XAML;
+using Robust.Client.UserInterface;
+
+namespace Content.Client._CD.Records.UI;
+
+/// <summary>
+/// The record editor tab that gets "injected" into the character editor.
+/// </summary>
+[GenerateTypedNameReferences]
+public sealed partial class RecordEditorGui : Control
+{
+    /// <summary>
+    /// Delegate that tells the editor to save records when the save button is pressed
+    /// </summary>
+    private readonly Action<PlayerProvidedCharacterRecords> _updateProfileRecords;
+    private PlayerProvidedCharacterRecords _records = default!;
+
+    public RecordEditorGui(Action<PlayerProvidedCharacterRecords> updateProfileRecords)
+    {
+        RobustXamlLoader.Load(this);
+        _updateProfileRecords = updateProfileRecords;
+
+        #region General
+
+        HeightEdit.OnTextChanged += args =>
+        {
+            if (!int.TryParse(args.Text, out var newHeight))
+                return;
+            UpdateImperialHeight(newHeight);
+            UpdateRecords(_records.WithHeight(newHeight));
+        };
+
+        WeightEdit.OnTextChanged += args =>
+        {
+            if (!int.TryParse(args.Text, out var newWeight))
+                return;
+            UpdateImperialWeight(newWeight);
+            UpdateRecords(_records.WithWeight(newWeight));
+        };
+
+        ContactNameEdit.OnTextChanged += args =>
+        {
+            UpdateRecords(_records.WithContactName(args.Text));
+        };
+
+        #endregion
+
+        #region Employment
+
+        WorkAuthCheckBox.OnToggled += args =>
+        {
+            UpdateRecords(_records.WithWorkAuth(args.Pressed));
+        };
+
+        #endregion
+
+        #region Security
+
+        IdentifyingFeaturesEdit.OnTextChanged += args =>
+        {
+            UpdateRecords(_records.WithIdentifyingFeatures(args.Text));
+        };
+
+        #endregion
+
+        #region Medical
+
+        AllergiesEdit.OnTextChanged += args =>
+        {
+            UpdateRecords(_records.WithAllergies(args.Text));
+        };
+
+        DrugAllergiesEdit.OnTextChanged += args =>
+        {
+            UpdateRecords(_records.WithDrugAllergies(args.Text));
+        };
+
+        PostmortemEdit.OnTextChanged += args =>
+        {
+            UpdateRecords(_records.WithPostmortemInstructions(args.Text));
+        };
+
+        #endregion
+
+        #region Entries
+
+        EntryEditorTabs.SetTabTitle(0, Loc.GetString("humanoid-profile-editor-cd-records-employment"));
+        EntryEditorTabs.SetTabTitle(1, Loc.GetString("department-Medical"));
+        EntryEditorTabs.SetTabTitle(2, Loc.GetString("department-Security"));
+
+        EmploymentEntrySelector.OnUpdateEntries += args =>
+        {
+            UpdateRecords(_records.WithEmploymentEntries(args.Entries));
+        };
+
+        MedicalEntrySelector.OnUpdateEntries += args =>
+        {
+            UpdateRecords(_records.WithMedicalEntries(args.Entries));
+        };
+
+        SecurityEntrySelector.OnUpdateEntries += args =>
+        {
+            UpdateRecords(_records.WithSecurityEntries(args.Entries));
+        };
+
+        #endregion
+    }
+
+    public void Update(HumanoidCharacterProfile? profile)
+    {
+        _records = profile?.CDCharacterRecords ?? PlayerProvidedCharacterRecords.DefaultRecords();
+        EmploymentEntrySelector.UpdateContents(_records.EmploymentEntries);
+        MedicalEntrySelector.UpdateContents(_records.MedicalEntries);
+        SecurityEntrySelector.UpdateContents(_records.SecurityEntries);
+        UpdateWidgets();
+    }
+
+    private void UpdateRecords(PlayerProvidedCharacterRecords records)
+    {
+        records.EnsureValid();
+        _records = records;
+        _updateProfileRecords(_records);
+        UpdateWidgets();
+    }
+
+    private void UpdateWidgets()
+    {
+        HeightEdit.SetText(_records.Height.ToString());
+        UpdateImperialHeight(_records.Height);
+        WeightEdit.SetText(_records.Weight.ToString());
+        UpdateImperialWeight(_records.Weight);
+        ContactNameEdit.SetText(_records.EmergencyContactName);
+
+        WorkAuthCheckBox.Pressed = _records.HasWorkAuthorization;
+
+        IdentifyingFeaturesEdit.SetText(_records.IdentifyingFeatures);
+
+        AllergiesEdit.SetText(_records.Allergies);
+        DrugAllergiesEdit.SetText(_records.DrugAllergies);
+        PostmortemEdit.SetText(_records.PostmortemInstructions);
+    }
+
+    private void UpdateImperialHeight(int newHeight)
+    {
+        HeightImperialLabel.Text = UnitConversion.GetImperialDisplayLength(newHeight);
+    }
+
+    private void UpdateImperialWeight(int newWeight)
+    {
+        WeightImperialLabel.Text = UnitConversion.GetImperialDisplayMass(newWeight);
+    }
+}
diff --git a/Content.Client/_CD/Records/UI/RecordEntryEditPopup.xaml b/Content.Client/_CD/Records/UI/RecordEntryEditPopup.xaml
new file mode 100644
index 0000000000..c76e57f724
--- /dev/null
+++ b/Content.Client/_CD/Records/UI/RecordEntryEditPopup.xaml
@@ -0,0 +1,36 @@
+<controls:FancyWindow xmlns="https://spacestation14.io"
+                      xmlns:controls="clr-namespace:Content.Client.UserInterface.Controls"
+                      MinSize="500 700"
+                      SetSize="600 700"
+                      Title="{Loc 'cd-records-entry-edit-popup-title'}">
+    <BoxContainer Margin="5 2 5 5" Orientation="Vertical" HorizontalExpand="True" SeparationOverride="2">
+        <!-- Header section -->
+        <PanelContainer StyleClasses="AngleRect">
+            <BoxContainer Orientation="Vertical" HorizontalExpand="True" Margin="4" SeparationOverride="8">
+                <LineEdit Name="TitleEdit" HorizontalExpand="True" PlaceHolder="{Loc 'cd-records-entry-edit-popup-title-placeholder'}"/>
+                <LineEdit Name="InvolvedEdit" HorizontalExpand="True" PlaceHolder="{Loc 'cd-records-entry-edit-popup-involved-placeholder'}"/>
+            </BoxContainer>
+        </PanelContainer>
+
+        <!-- Content section with styled background -->
+        <PanelContainer Name="ContentPanel" VerticalExpand="True">
+            <TextEdit Name="DescriptionEdit"
+                      HorizontalExpand="True"
+                      VerticalExpand="True"
+                      Margin="8 4 8 8"/>
+        </PanelContainer>
+
+        <!-- Save button and validation section -->
+        <BoxContainer Orientation="Vertical" HorizontalExpand="True" SeparationOverride="4">
+            <PanelContainer StyleClasses="AngleRect">
+                <Button Access="Public"
+                        Name="SaveButton"
+                        Text="{Loc 'cd-records-entry-edit-popup-save'}"
+                        Margin="4"/>
+            </PanelContainer>
+            <Label Name="ValidationLabel"
+                   HorizontalExpand="True"
+                   HorizontalAlignment="Center"/>
+        </BoxContainer>
+    </BoxContainer>
+</controls:FancyWindow>
diff --git a/Content.Client/_CD/Records/UI/RecordEntryEditPopup.xaml.cs b/Content.Client/_CD/Records/UI/RecordEntryEditPopup.xaml.cs
new file mode 100644
index 0000000000..df9e0951f5
--- /dev/null
+++ b/Content.Client/_CD/Records/UI/RecordEntryEditPopup.xaml.cs
@@ -0,0 +1,145 @@
+using Content.Client.UserInterface.Controls;
+using Content.Shared._CD.Records;
+using Robust.Client.AutoGenerated;
+using Robust.Client.Graphics;
+using Robust.Client.UserInterface.XAML;
+using Robust.Shared.Utility;
+using System.Linq;
+
+namespace Content.Client._CD.Records.UI;
+
+[GenerateTypedNameReferences]
+public sealed partial class RecordEntryEditPopup : FancyWindow
+{
+    private bool _isValid;
+
+    private record struct ValidationRule(
+        Func<bool> IsInvalid,
+        string LocalizationKey,
+        (string, object)[]? Parameters = null);
+
+    public RecordEntryEditPopup()
+    {
+        RobustXamlLoader.Load(this);
+        IoCManager.InjectDependencies(this);
+
+        ValidationLabel.FontColorOverride = CharacterRecordViewer.ErrorColor;
+        ValidationLabel.Visible = false;
+
+        // Style the content panel
+        var styleBox = new StyleBoxFlat
+        {
+            BackgroundColor = CharacterRecordViewer.ContentPanelColor,
+            BorderColor = CharacterRecordViewer.BorderColor,
+            BorderThickness = new Thickness(1),
+        };
+
+        ContentPanel.PanelOverride = styleBox;
+
+        SetupEventHandlers();
+    }
+
+    private void SetupEventHandlers()
+    {
+        TitleEdit.OnTextChanged += args =>
+        {
+            if (args.Text.Length > PlayerProvidedCharacterRecords.TextMedLen)
+            {
+                TitleEdit.Text = args.Text[..PlayerProvidedCharacterRecords.TextMedLen];
+            }
+            ValidateFields();
+        };
+
+        InvolvedEdit.OnTextChanged += args =>
+        {
+            if (args.Text.Length > PlayerProvidedCharacterRecords.TextMedLen)
+            {
+                InvolvedEdit.Text = args.Text[..PlayerProvidedCharacterRecords.TextMedLen];
+            }
+            ValidateFields();
+        };
+
+        DescriptionEdit.OnTextChanged += _ => ValidateFields();
+
+        SaveButton.OnPressed += _ =>
+        {
+            if (!_isValid)
+                return;
+            Close();
+        };
+
+        DescriptionEdit.Placeholder =
+            new Rope.Leaf(Loc.GetString("cd-records-entry-edit-popup-description-placeholder"));
+
+        TitleEdit.PlaceHolder = Loc.GetString("cd-records-entry-edit-popup-title-placeholder");
+        InvolvedEdit.PlaceHolder = Loc.GetString("cd-records-entry-edit-popup-involved-placeholder");
+    }
+
+    private void ValidateFields()
+    {
+        var descriptionText = Rope.Collapse(DescriptionEdit.TextRope);
+        var descriptionLength = descriptionText.Length;
+
+        // Validation rules in priority order
+        // Overcomplicated into oblivion just because I didn't like how the else if statements looked
+        var rules = new[]
+        {
+            new ValidationRule(
+                () => string.IsNullOrWhiteSpace(TitleEdit.Text),
+                "cd-records-entry-edit-popup-title-required"),
+
+            new ValidationRule(
+                () => string.IsNullOrWhiteSpace(InvolvedEdit.Text),
+                "cd-records-entry-edit-popup-involved-required"),
+
+            new ValidationRule(
+                () => string.IsNullOrWhiteSpace(descriptionText),
+                "cd-records-entry-edit-popup-description-required"),
+
+            new ValidationRule(
+                () => descriptionLength > PlayerProvidedCharacterRecords.TextVeryLargeLen,
+                "cd-records-entry-edit-popup-description-too-long",
+                new[]
+                {
+                    ("current", (object)descriptionLength),
+                    ("max", PlayerProvidedCharacterRecords.TextVeryLargeLen)
+                }),
+        };
+
+        // Find first failing validation rule
+        var failedRule = rules.FirstOrDefault(rule => rule.IsInvalid());
+
+        if (failedRule.IsInvalid != null)
+        {
+            ValidationLabel.Text = failedRule.Parameters != null
+                ? Loc.GetString(failedRule.LocalizationKey, failedRule.Parameters)
+                : Loc.GetString(failedRule.LocalizationKey);
+            ValidationLabel.Visible = true;
+            _isValid = false;
+        }
+        else
+        {
+            ValidationLabel.Visible = false;
+            _isValid = true;
+        }
+
+        SaveButton.Disabled = !_isValid;
+    }
+
+    public PlayerProvidedCharacterRecords.RecordEntry GetContents()
+    {
+        var desc = Rope.Collapse(DescriptionEdit.TextRope).Trim();
+        return new PlayerProvidedCharacterRecords.RecordEntry(
+            TitleEdit.Text.Trim(),
+            InvolvedEdit.Text.Trim(),
+            desc);
+    }
+
+    public void SetContents(PlayerProvidedCharacterRecords.RecordEntry entry)
+    {
+        TitleEdit.Text = entry.Title;
+        InvolvedEdit.Text = entry.Involved;
+        DescriptionEdit.TextRope = new Rope.Leaf(entry.Description);
+        ValidateFields();
+    }
+}
diff --git a/Content.Client/_CD/Records/UI/RecordEntryViewPopup.xaml b/Content.Client/_CD/Records/UI/RecordEntryViewPopup.xaml
new file mode 100644
index 0000000000..b7f1ce16be
--- /dev/null
+++ b/Content.Client/_CD/Records/UI/RecordEntryViewPopup.xaml
@@ -0,0 +1,38 @@
+<controls:FancyWindow xmlns="https://spacestation14.io"
+                      xmlns:controls="clr-namespace:Content.Client.UserInterface.Controls"
+                      MinSize="500 700"
+                      SetSize="600 700"
+                      Title="{Loc 'cd-records-entry-view-popup-title'}">
+    <BoxContainer Margin="5 2 5 5" Orientation="Vertical" HorizontalExpand="True" SeparationOverride="2">
+        <!-- Header section -->
+        <PanelContainer StyleClasses="AngleRect">
+            <BoxContainer Orientation="Vertical" HorizontalExpand="True" Margin="4">
+                <BoxContainer Orientation="Horizontal" HorizontalExpand="True">
+                    <Label Text="{Loc 'cd-character-records-entry-view-title'}" StyleClasses="LabelBig"/>
+                    <Control MinWidth="5"/>
+                    <RichTextLabel HorizontalAlignment="Right" Name="EntryTitle" HorizontalExpand="True" StyleClasses="LabelBig" />
+                </BoxContainer>
+                <BoxContainer Orientation="Horizontal" HorizontalExpand="True">
+                    <Label Text="{Loc 'cd-character-records-entry-view-involved'}" StyleClasses="LabelBig"/>
+                    <Control MinWidth="5"/>
+                    <RichTextLabel HorizontalAlignment="Right" Name="EntryInvolved" HorizontalExpand="True" StyleClasses="LabelBig"/>
+                </BoxContainer>
+            </BoxContainer>
+        </PanelContainer>
+
+        <!-- Content section with styled background -->
+        <PanelContainer Name="ContentPanel" VerticalExpand="True">
+            <ScrollContainer HorizontalExpand="True"
+                           VerticalExpand="True"
+                           HScrollEnabled="False">
+                <BoxContainer Orientation="Vertical"
+                            HorizontalExpand="True"
+                            Margin="8 4 8 8">
+                    <RichTextLabel Name="EntryDesc"
+                                 HorizontalExpand="True"
+                                 Margin="4"/>
+                </BoxContainer>
+            </ScrollContainer>
+        </PanelContainer>
+    </BoxContainer>
+</controls:FancyWindow>
diff --git a/Content.Client/_CD/Records/UI/RecordEntryViewPopup.xaml.cs b/Content.Client/_CD/Records/UI/RecordEntryViewPopup.xaml.cs
new file mode 100644
index 0000000000..d347f9d524
--- /dev/null
+++ b/Content.Client/_CD/Records/UI/RecordEntryViewPopup.xaml.cs
@@ -0,0 +1,46 @@
+using Content.Client.UserInterface.Controls;
+using Content.Shared._CD.Records;
+using Robust.Client.AutoGenerated;
+using Robust.Client.Graphics;
+using Robust.Client.UserInterface.RichText;
+using Robust.Client.UserInterface.XAML;
+using Robust.Shared.Utility;
+
+namespace Content.Client._CD.Records.UI;
+
+[GenerateTypedNameReferences]
+public sealed partial class RecordEntryViewPopup : FancyWindow
+{
+    // Font tags bad
+    private static readonly Type[] AllowedTags =
+    [
+        typeof(BoldItalicTag),
+        typeof(BoldTag),
+        typeof(BulletTag),
+        typeof(ColorTag),
+        typeof(HeadingTag),
+        typeof(ItalicTag),
+    ];
+
+    public RecordEntryViewPopup()
+    {
+        RobustXamlLoader.Load(this);
+
+        // Create a styled box for the content panel
+        var styleBox = new StyleBoxFlat
+        {
+            BackgroundColor = CharacterRecordViewer.ContentPanelColor,
+            BorderColor = CharacterRecordViewer.BorderColor,
+            BorderThickness = new Thickness(1),
+        };
+
+        ContentPanel.PanelOverride = styleBox;
+    }
+
+    public void SetContents(PlayerProvidedCharacterRecords.RecordEntry entry)
+    {
+        EntryTitle.SetMessage(entry.Title);
+        EntryInvolved.SetMessage(entry.Involved);
+        EntryDesc.SetMessage(FormattedMessage.FromMarkupPermissive(entry.Description.Trim()), AllowedTags);
+    }
+}
diff --git a/Content.Client/_CD/Records/UI/RecordLongItemDisplay.cs b/Content.Client/_CD/Records/UI/RecordLongItemDisplay.cs
new file mode 100644
index 0000000000..7eca7114f7
--- /dev/null
+++ b/Content.Client/_CD/Records/UI/RecordLongItemDisplay.cs
@@ -0,0 +1,65 @@
+using Robust.Client.UserInterface;
+using Robust.Client.UserInterface.Controls;
+
+namespace Content.Client._CD.Records.UI;
+
+/// <summary>
+/// Widget that displays the record on one line if it is short enough, and on two lines if it is
+/// too long. This should only be used if you know the length may be long enough to break things when
+/// using a normal Label.
+/// </summary>
+public sealed class RecordLongItemDisplay : BoxContainer
+{
+    private const int MaxShortLength = 32;
+
+    public string? Title
+    {
+        get => _titleLabel.Text;
+        set => _titleLabel.Text = value;
+    }
+
+    // Row containing the title and short value
+    private readonly BoxContainer _firstRow = new()
+    {
+        Orientation = LayoutOrientation.Horizontal,
+        HorizontalExpand = true
+    };
+    // Row containing the long value
+    private readonly BoxContainer _secondRow = new()
+    {
+        Orientation = LayoutOrientation.Horizontal,
+        HorizontalExpand = true,
+        Visible = false,
+    };
+    private readonly Label _titleLabel = new();
+    private readonly Label _shortContents = new() { Visible = true, Align = Label.AlignMode.Right };
+    private readonly RichTextLabel _longContents = new() { HorizontalExpand = true };
+
+    public RecordLongItemDisplay()
+    {
+        Orientation = LayoutOrientation.Vertical;
+        _firstRow.AddChild(_titleLabel);
+        _firstRow.AddChild(new Control() { HorizontalExpand = true });
+        _firstRow.AddChild(_shortContents);
+        AddChild(_firstRow);
+        _secondRow.AddChild(new Control() { HorizontalExpand = true, SizeFlagsStretchRatio = 0.15f});
+        _secondRow.AddChild(_longContents);
+        AddChild(_secondRow);
+    }
+
+    public void SetValue(string s)
+    {
+        if (s.Length > MaxShortLength)
+        {
+            _longContents.SetMessage(s);
+            _secondRow.Visible = true;
+            _shortContents.Visible = false;
+        }
+        else
+        {
+            _shortContents.Text = s;
+            _shortContents.Visible = true;
+            _secondRow.Visible = false;
+        }
+    }
+}
diff --git a/Content.Client/_CD/Records/UI/UnitConversion.cs b/Content.Client/_CD/Records/UI/UnitConversion.cs
new file mode 100644
index 0000000000..239ec6937e
--- /dev/null
+++ b/Content.Client/_CD/Records/UI/UnitConversion.cs
@@ -0,0 +1,16 @@
+namespace Content.Client._CD.Records.UI;
+
+public static class UnitConversion
+{
+    public static string GetImperialDisplayLength(int lengthCm)
+    {
+        var heightIn = (int) Math.Round(lengthCm * 0.3937007874 /* cm to in*/);
+        return $"({heightIn / 12}'{heightIn % 12}'')";
+    }
+
+    public static string GetImperialDisplayMass(int massKg)
+    {
+        var weightLbs = (int) Math.Round(massKg * 2.2046226218 /* kg to lbs */);
+        return $"({weightLbs} lbs)";
+    }
+}
diff --git a/Content.Server.Database/CDModel.cs b/Content.Server.Database/CDModel.cs
new file mode 100644
index 0000000000..f32de41a52
--- /dev/null
+++ b/Content.Server.Database/CDModel.cs
@@ -0,0 +1,56 @@
+// File to store as much CD related database things outside of Model.cs
+
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations.Schema;
+using System.Text.Json;
+using Microsoft.EntityFrameworkCore;
+
+namespace Content.Server.Database;
+
+public static class CDModel
+{
+    /// <summary>
+    /// Stores CD Character data separately from the main Profile. This is done to work around a bug
+    /// in EFCore migrations.
+    /// <p />
+    /// There is no way of forcing a dependent table to exist in EFCore (according to MS).
+    /// You must always account for the possibility of this table not existing.
+    /// </summary>
+    public class CDProfile
+    {
+        public int Id { get; set; }
+
+        public int ProfileId { get; set; }
+        public Profile Profile { get; set; } = null!;
+
+        public float Height { get; set; } = 1f;
+
+        [Column("character_records", TypeName = "jsonb")]
+        public JsonDocument? CharacterRecords { get; set; }
+
+        public List<CharacterRecordEntry> CharacterRecordEntries { get; set; } = new();
+
+    }
+    public enum DbRecordEntryType : byte
+    {
+         Medical = 0, Security = 1, Employment = 2
+    }
+
+    [Table("cd_character_record_entries"), Index(nameof(Id))]
+    public sealed class CharacterRecordEntry
+    {
+        public int Id { get; set;  }
+
+        public string Title { get; set; } = null!;
+
+        public string Involved { get; set; } = null!;
+
+        public string Description { get; set; } = null!;
+
+        public DbRecordEntryType Type { get; set; }
+
+        public int CDProfileId { get; set; }
+        public CDProfile CDProfile { get; set; } = null!;
+    }
+}
diff --git a/Content.Server.Database/Migrations/Postgres/20250303043202_CosmaticDriftCharacterRecords.Designer.cs b/Content.Server.Database/Migrations/Postgres/20250303043202_CosmaticDriftCharacterRecords.Designer.cs
new file mode 100644
index 0000000000..4f6dd27fda
--- /dev/null
+++ b/Content.Server.Database/Migrations/Postgres/20250303043202_CosmaticDriftCharacterRecords.Designer.cs
@@ -0,0 +1,2216 @@
+// <auto-generated />
+using System;
+using System.Net;
+using System.Text.Json;
+using Content.Server.Database;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+using NpgsqlTypes;
+
+#nullable disable
+
+namespace Content.Server.Database.Migrations.Postgres
+{
+    [DbContext(typeof(PostgresServerDbContext))]
+    [Migration("20250303043202_CosmaticDriftCharacterRecords")]
+    partial class CosmaticDriftCharacterRecords
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "8.0.0")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("Content.Server.Database.Admin", b =>
+                {
+                    b.Property<Guid>("UserId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid")
+                        .HasColumnName("user_id");
+
+                    b.Property<int?>("AdminRankId")
+                        .HasColumnType("integer")
+                        .HasColumnName("admin_rank_id");
+
+                    b.Property<bool>("Deadminned")
+                        .HasColumnType("boolean")
+                        .HasColumnName("deadminned");
+
+                    b.Property<bool>("Suspended")
+                        .HasColumnType("boolean")
+                        .HasColumnName("suspended");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("text")
+                        .HasColumnName("title");
+
+                    b.HasKey("UserId")
+                        .HasName("PK_admin");
+
+                    b.HasIndex("AdminRankId")
+                        .HasDatabaseName("IX_admin_admin_rank_id");
+
+                    b.ToTable("admin", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminFlag", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("admin_flag_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<Guid>("AdminId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("admin_id");
+
+                    b.Property<string>("Flag")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("flag");
+
+                    b.Property<bool>("Negative")
+                        .HasColumnType("boolean")
+                        .HasColumnName("negative");
+
+                    b.HasKey("Id")
+                        .HasName("PK_admin_flag");
+
+                    b.HasIndex("AdminId")
+                        .HasDatabaseName("IX_admin_flag_admin_id");
+
+                    b.HasIndex("Flag", "AdminId")
+                        .IsUnique();
+
+                    b.ToTable("admin_flag", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminLog", b =>
+                {
+                    b.Property<int>("RoundId")
+                        .HasColumnType("integer")
+                        .HasColumnName("round_id");
+
+                    b.Property<int>("Id")
+                        .HasColumnType("integer")
+                        .HasColumnName("admin_log_id");
+
+                    b.Property<DateTime>("Date")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("date");
+
+                    b.Property<short>("Impact")
+                        .HasColumnType("smallint")
+                        .HasColumnName("impact");
+
+                    b.Property<JsonDocument>("Json")
+                        .IsRequired()
+                        .HasColumnType("jsonb")
+                        .HasColumnName("json");
+
+                    b.Property<string>("Message")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("message");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("integer")
+                        .HasColumnName("type");
+
+                    b.HasKey("RoundId", "Id")
+                        .HasName("PK_admin_log");
+
+                    b.HasIndex("Date");
+
+                    b.HasIndex("Message")
+                        .HasAnnotation("Npgsql:TsVectorConfig", "english");
+
+                    NpgsqlIndexBuilderExtensions.HasMethod(b.HasIndex("Message"), "GIN");
+
+                    b.HasIndex("Type")
+                        .HasDatabaseName("IX_admin_log_type");
+
+                    b.ToTable("admin_log", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminLogPlayer", b =>
+                {
+                    b.Property<int>("RoundId")
+                        .HasColumnType("integer")
+                        .HasColumnName("round_id");
+
+                    b.Property<int>("LogId")
+                        .HasColumnType("integer")
+                        .HasColumnName("log_id");
+
+                    b.Property<Guid>("PlayerUserId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("player_user_id");
+
+                    b.HasKey("RoundId", "LogId", "PlayerUserId")
+                        .HasName("PK_admin_log_player");
+
+                    b.HasIndex("PlayerUserId")
+                        .HasDatabaseName("IX_admin_log_player_player_user_id");
+
+                    b.ToTable("admin_log_player", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminMessage", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("admin_messages_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("created_at");
+
+                    b.Property<Guid?>("CreatedById")
+                        .HasColumnType("uuid")
+                        .HasColumnName("created_by_id");
+
+                    b.Property<bool>("Deleted")
+                        .HasColumnType("boolean")
+                        .HasColumnName("deleted");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("deleted_at");
+
+                    b.Property<Guid?>("DeletedById")
+                        .HasColumnType("uuid")
+                        .HasColumnName("deleted_by_id");
+
+                    b.Property<bool>("Dismissed")
+                        .HasColumnType("boolean")
+                        .HasColumnName("dismissed");
+
+                    b.Property<DateTime?>("ExpirationTime")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("expiration_time");
+
+                    b.Property<DateTime?>("LastEditedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("last_edited_at");
+
+                    b.Property<Guid?>("LastEditedById")
+                        .HasColumnType("uuid")
+                        .HasColumnName("last_edited_by_id");
+
+                    b.Property<string>("Message")
+                        .IsRequired()
+                        .HasMaxLength(4096)
+                        .HasColumnType("character varying(4096)")
+                        .HasColumnName("message");
+
+                    b.Property<Guid?>("PlayerUserId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("player_user_id");
+
+                    b.Property<TimeSpan>("PlaytimeAtNote")
+                        .HasColumnType("interval")
+                        .HasColumnName("playtime_at_note");
+
+                    b.Property<int?>("RoundId")
+                        .HasColumnType("integer")
+                        .HasColumnName("round_id");
+
+                    b.Property<bool>("Seen")
+                        .HasColumnType("boolean")
+                        .HasColumnName("seen");
+
+                    b.HasKey("Id")
+                        .HasName("PK_admin_messages");
+
+                    b.HasIndex("CreatedById");
+
+                    b.HasIndex("DeletedById");
+
+                    b.HasIndex("LastEditedById");
+
+                    b.HasIndex("PlayerUserId")
+                        .HasDatabaseName("IX_admin_messages_player_user_id");
+
+                    b.HasIndex("RoundId")
+                        .HasDatabaseName("IX_admin_messages_round_id");
+
+                    b.ToTable("admin_messages", null, t =>
+                        {
+                            t.HasCheckConstraint("NotDismissedAndSeen", "NOT dismissed OR seen");
+                        });
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminNote", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("admin_notes_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("created_at");
+
+                    b.Property<Guid?>("CreatedById")
+                        .HasColumnType("uuid")
+                        .HasColumnName("created_by_id");
+
+                    b.Property<bool>("Deleted")
+                        .HasColumnType("boolean")
+                        .HasColumnName("deleted");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("deleted_at");
+
+                    b.Property<Guid?>("DeletedById")
+                        .HasColumnType("uuid")
+                        .HasColumnName("deleted_by_id");
+
+                    b.Property<DateTime?>("ExpirationTime")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("expiration_time");
+
+                    b.Property<DateTime?>("LastEditedAt")
+                        .IsRequired()
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("last_edited_at");
+
+                    b.Property<Guid?>("LastEditedById")
+                        .HasColumnType("uuid")
+                        .HasColumnName("last_edited_by_id");
+
+                    b.Property<string>("Message")
+                        .IsRequired()
+                        .HasMaxLength(4096)
+                        .HasColumnType("character varying(4096)")
+                        .HasColumnName("message");
+
+                    b.Property<Guid?>("PlayerUserId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("player_user_id");
+
+                    b.Property<TimeSpan>("PlaytimeAtNote")
+                        .HasColumnType("interval")
+                        .HasColumnName("playtime_at_note");
+
+                    b.Property<int?>("RoundId")
+                        .HasColumnType("integer")
+                        .HasColumnName("round_id");
+
+                    b.Property<bool>("Secret")
+                        .HasColumnType("boolean")
+                        .HasColumnName("secret");
+
+                    b.Property<int>("Severity")
+                        .HasColumnType("integer")
+                        .HasColumnName("severity");
+
+                    b.HasKey("Id")
+                        .HasName("PK_admin_notes");
+
+                    b.HasIndex("CreatedById");
+
+                    b.HasIndex("DeletedById");
+
+                    b.HasIndex("LastEditedById");
+
+                    b.HasIndex("PlayerUserId")
+                        .HasDatabaseName("IX_admin_notes_player_user_id");
+
+                    b.HasIndex("RoundId")
+                        .HasDatabaseName("IX_admin_notes_round_id");
+
+                    b.ToTable("admin_notes", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminRank", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("admin_rank_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("name");
+
+                    b.HasKey("Id")
+                        .HasName("PK_admin_rank");
+
+                    b.ToTable("admin_rank", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminRankFlag", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("admin_rank_flag_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("AdminRankId")
+                        .HasColumnType("integer")
+                        .HasColumnName("admin_rank_id");
+
+                    b.Property<string>("Flag")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("flag");
+
+                    b.HasKey("Id")
+                        .HasName("PK_admin_rank_flag");
+
+                    b.HasIndex("AdminRankId");
+
+                    b.HasIndex("Flag", "AdminRankId")
+                        .IsUnique();
+
+                    b.ToTable("admin_rank_flag", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminWatchlist", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("admin_watchlists_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("created_at");
+
+                    b.Property<Guid?>("CreatedById")
+                        .HasColumnType("uuid")
+                        .HasColumnName("created_by_id");
+
+                    b.Property<bool>("Deleted")
+                        .HasColumnType("boolean")
+                        .HasColumnName("deleted");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("deleted_at");
+
+                    b.Property<Guid?>("DeletedById")
+                        .HasColumnType("uuid")
+                        .HasColumnName("deleted_by_id");
+
+                    b.Property<DateTime?>("ExpirationTime")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("expiration_time");
+
+                    b.Property<DateTime?>("LastEditedAt")
+                        .IsRequired()
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("last_edited_at");
+
+                    b.Property<Guid?>("LastEditedById")
+                        .HasColumnType("uuid")
+                        .HasColumnName("last_edited_by_id");
+
+                    b.Property<string>("Message")
+                        .IsRequired()
+                        .HasMaxLength(4096)
+                        .HasColumnType("character varying(4096)")
+                        .HasColumnName("message");
+
+                    b.Property<Guid?>("PlayerUserId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("player_user_id");
+
+                    b.Property<TimeSpan>("PlaytimeAtNote")
+                        .HasColumnType("interval")
+                        .HasColumnName("playtime_at_note");
+
+                    b.Property<int?>("RoundId")
+                        .HasColumnType("integer")
+                        .HasColumnName("round_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_admin_watchlists");
+
+                    b.HasIndex("CreatedById");
+
+                    b.HasIndex("DeletedById");
+
+                    b.HasIndex("LastEditedById");
+
+                    b.HasIndex("PlayerUserId")
+                        .HasDatabaseName("IX_admin_watchlists_player_user_id");
+
+                    b.HasIndex("RoundId")
+                        .HasDatabaseName("IX_admin_watchlists_round_id");
+
+                    b.ToTable("admin_watchlists", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Antag", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("antag_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AntagName")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("antag_name");
+
+                    b.Property<int>("ProfileId")
+                        .HasColumnType("integer")
+                        .HasColumnName("profile_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_antag");
+
+                    b.HasIndex("ProfileId", "AntagName")
+                        .IsUnique();
+
+                    b.ToTable("antag", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AssignedUserId", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("assigned_user_id_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("user_id");
+
+                    b.Property<string>("UserName")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("user_name");
+
+                    b.HasKey("Id")
+                        .HasName("PK_assigned_user_id");
+
+                    b.HasIndex("UserId")
+                        .IsUnique();
+
+                    b.HasIndex("UserName")
+                        .IsUnique();
+
+                    b.ToTable("assigned_user_id", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.BanTemplate", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("ban_template_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<bool>("AutoDelete")
+                        .HasColumnType("boolean")
+                        .HasColumnName("auto_delete");
+
+                    b.Property<int>("ExemptFlags")
+                        .HasColumnType("integer")
+                        .HasColumnName("exempt_flags");
+
+                    b.Property<bool>("Hidden")
+                        .HasColumnType("boolean")
+                        .HasColumnName("hidden");
+
+                    b.Property<TimeSpan>("Length")
+                        .HasColumnType("interval")
+                        .HasColumnName("length");
+
+                    b.Property<string>("Reason")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("reason");
+
+                    b.Property<int>("Severity")
+                        .HasColumnType("integer")
+                        .HasColumnName("severity");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("title");
+
+                    b.HasKey("Id")
+                        .HasName("PK_ban_template");
+
+                    b.ToTable("ban_template", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Blacklist", b =>
+                {
+                    b.Property<Guid>("UserId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid")
+                        .HasColumnName("user_id");
+
+                    b.HasKey("UserId")
+                        .HasName("PK_blacklist");
+
+                    b.ToTable("blacklist", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.CDModel+CDProfile", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("cdprofile_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<JsonDocument>("CharacterRecords")
+                        .HasColumnType("jsonb")
+                        .HasColumnName("character_records");
+
+                    b.Property<float>("Height")
+                        .HasColumnType("real")
+                        .HasColumnName("height");
+
+                    b.Property<int>("ProfileId")
+                        .HasColumnType("integer")
+                        .HasColumnName("profile_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_cdprofile");
+
+                    b.HasIndex("ProfileId")
+                        .IsUnique();
+
+                    b.ToTable("cdprofile", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.CDModel+CharacterRecordEntry", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("cd_character_record_entries_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("CDProfileId")
+                        .HasColumnType("integer")
+                        .HasColumnName("cdprofile_id");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("description");
+
+                    b.Property<string>("Involved")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("involved");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("title");
+
+                    b.Property<byte>("Type")
+                        .HasColumnType("smallint")
+                        .HasColumnName("type");
+
+                    b.HasKey("Id")
+                        .HasName("PK_cd_character_record_entries");
+
+                    b.HasIndex("CDProfileId");
+
+                    b.HasIndex("Id")
+                        .HasDatabaseName("IX_cd_character_record_entries_cd_character_record_entries_id");
+
+                    b.ToTable("cd_character_record_entries", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ConnectionLog", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("connection_log_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<IPAddress>("Address")
+                        .IsRequired()
+                        .HasColumnType("inet")
+                        .HasColumnName("address");
+
+                    b.Property<byte?>("Denied")
+                        .HasColumnType("smallint")
+                        .HasColumnName("denied");
+
+                    b.Property<int>("ServerId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValue(0)
+                        .HasColumnName("server_id");
+
+                    b.Property<DateTime>("Time")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("time");
+
+                    b.Property<float>("Trust")
+                        .HasColumnType("real")
+                        .HasColumnName("trust");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("user_id");
+
+                    b.Property<string>("UserName")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("user_name");
+
+                    b.HasKey("Id")
+                        .HasName("PK_connection_log");
+
+                    b.HasIndex("ServerId")
+                        .HasDatabaseName("IX_connection_log_server_id");
+
+                    b.HasIndex("Time");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("connection_log", null, t =>
+                        {
+                            t.HasCheckConstraint("AddressNotIPv6MappedIPv4", "NOT inet '::ffff:0.0.0.0/96' >>= address");
+                        });
+                });
+
+            modelBuilder.Entity("Content.Server.Database.IPIntelCache", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("ipintel_cache_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<IPAddress>("Address")
+                        .IsRequired()
+                        .HasColumnType("inet")
+                        .HasColumnName("address");
+
+                    b.Property<float>("Score")
+                        .HasColumnType("real")
+                        .HasColumnName("score");
+
+                    b.Property<DateTime>("Time")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("time");
+
+                    b.HasKey("Id")
+                        .HasName("PK_ipintel_cache");
+
+                    b.ToTable("ipintel_cache", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Job", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("job_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("JobName")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("job_name");
+
+                    b.Property<int>("Priority")
+                        .HasColumnType("integer")
+                        .HasColumnName("priority");
+
+                    b.Property<int>("ProfileId")
+                        .HasColumnType("integer")
+                        .HasColumnName("profile_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_job");
+
+                    b.HasIndex("ProfileId");
+
+                    b.HasIndex("ProfileId", "JobName")
+                        .IsUnique();
+
+                    b.HasIndex(new[] { "ProfileId" }, "IX_job_one_high_priority")
+                        .IsUnique()
+                        .HasFilter("priority = 3");
+
+                    b.ToTable("job", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.PlayTime", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("play_time_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<Guid>("PlayerId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("player_id");
+
+                    b.Property<TimeSpan>("TimeSpent")
+                        .HasColumnType("interval")
+                        .HasColumnName("time_spent");
+
+                    b.Property<string>("Tracker")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("tracker");
+
+                    b.HasKey("Id")
+                        .HasName("PK_play_time");
+
+                    b.HasIndex("PlayerId", "Tracker")
+                        .IsUnique();
+
+                    b.ToTable("play_time", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Player", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("player_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("FirstSeenTime")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("first_seen_time");
+
+                    b.Property<DateTime?>("LastReadRules")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("last_read_rules");
+
+                    b.Property<IPAddress>("LastSeenAddress")
+                        .IsRequired()
+                        .HasColumnType("inet")
+                        .HasColumnName("last_seen_address");
+
+                    b.Property<DateTime>("LastSeenTime")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("last_seen_time");
+
+                    b.Property<string>("LastSeenUserName")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("last_seen_user_name");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("user_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_player");
+
+                    b.HasAlternateKey("UserId")
+                        .HasName("ak_player_user_id");
+
+                    b.HasIndex("LastSeenUserName");
+
+                    b.HasIndex("UserId")
+                        .IsUnique();
+
+                    b.ToTable("player", null, t =>
+                        {
+                            t.HasCheckConstraint("LastSeenAddressNotIPv6MappedIPv4", "NOT inet '::ffff:0.0.0.0/96' >>= last_seen_address");
+                        });
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Preference", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("preference_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AdminOOCColor")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("admin_ooc_color");
+
+                    b.Property<int>("SelectedCharacterSlot")
+                        .HasColumnType("integer")
+                        .HasColumnName("selected_character_slot");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("user_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_preference");
+
+                    b.HasIndex("UserId")
+                        .IsUnique();
+
+                    b.ToTable("preference", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Profile", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("profile_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("Age")
+                        .HasColumnType("integer")
+                        .HasColumnName("age");
+
+                    b.Property<string>("CharacterName")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("char_name");
+
+                    b.Property<string>("EyeColor")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("eye_color");
+
+                    b.Property<string>("FacialHairColor")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("facial_hair_color");
+
+                    b.Property<string>("FacialHairName")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("facial_hair_name");
+
+                    b.Property<string>("FlavorText")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("flavor_text");
+
+                    b.Property<string>("Gender")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("gender");
+
+                    b.Property<string>("HairColor")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("hair_color");
+
+                    b.Property<string>("HairName")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("hair_name");
+
+                    b.Property<JsonDocument>("Markings")
+                        .HasColumnType("jsonb")
+                        .HasColumnName("markings");
+
+                    b.Property<int>("PreferenceId")
+                        .HasColumnType("integer")
+                        .HasColumnName("preference_id");
+
+                    b.Property<int>("PreferenceUnavailable")
+                        .HasColumnType("integer")
+                        .HasColumnName("pref_unavailable");
+
+                    b.Property<string>("Sex")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("sex");
+
+                    b.Property<string>("SkinColor")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("skin_color");
+
+                    b.Property<int>("Slot")
+                        .HasColumnType("integer")
+                        .HasColumnName("slot");
+
+                    b.Property<int>("SpawnPriority")
+                        .HasColumnType("integer")
+                        .HasColumnName("spawn_priority");
+
+                    b.Property<string>("Species")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("species");
+
+                    b.HasKey("Id")
+                        .HasName("PK_profile");
+
+                    b.HasIndex("PreferenceId")
+                        .HasDatabaseName("IX_profile_preference_id");
+
+                    b.HasIndex("Slot", "PreferenceId")
+                        .IsUnique();
+
+                    b.ToTable("profile", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ProfileLoadout", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("profile_loadout_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("LoadoutName")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("loadout_name");
+
+                    b.Property<int>("ProfileLoadoutGroupId")
+                        .HasColumnType("integer")
+                        .HasColumnName("profile_loadout_group_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_profile_loadout");
+
+                    b.HasIndex("ProfileLoadoutGroupId");
+
+                    b.ToTable("profile_loadout", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ProfileLoadoutGroup", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("profile_loadout_group_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("GroupName")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("group_name");
+
+                    b.Property<int>("ProfileRoleLoadoutId")
+                        .HasColumnType("integer")
+                        .HasColumnName("profile_role_loadout_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_profile_loadout_group");
+
+                    b.HasIndex("ProfileRoleLoadoutId");
+
+                    b.ToTable("profile_loadout_group", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ProfileRoleLoadout", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("profile_role_loadout_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ProfileId")
+                        .HasColumnType("integer")
+                        .HasColumnName("profile_id");
+
+                    b.Property<string>("RoleName")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("role_name");
+
+                    b.HasKey("Id")
+                        .HasName("PK_profile_role_loadout");
+
+                    b.HasIndex("ProfileId");
+
+                    b.ToTable("profile_role_loadout", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.RoleWhitelist", b =>
+                {
+                    b.Property<Guid>("PlayerUserId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("player_user_id");
+
+                    b.Property<string>("RoleId")
+                        .HasColumnType("text")
+                        .HasColumnName("role_id");
+
+                    b.HasKey("PlayerUserId", "RoleId")
+                        .HasName("PK_role_whitelists");
+
+                    b.ToTable("role_whitelists", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Round", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("round_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ServerId")
+                        .HasColumnType("integer")
+                        .HasColumnName("server_id");
+
+                    b.Property<DateTime?>("StartDate")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("start_date");
+
+                    b.HasKey("Id")
+                        .HasName("PK_round");
+
+                    b.HasIndex("ServerId")
+                        .HasDatabaseName("IX_round_server_id");
+
+                    b.HasIndex("StartDate");
+
+                    b.ToTable("round", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Server", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("server_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("name");
+
+                    b.HasKey("Id")
+                        .HasName("PK_server");
+
+                    b.ToTable("server", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerBan", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("server_ban_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<NpgsqlInet?>("Address")
+                        .HasColumnType("inet")
+                        .HasColumnName("address");
+
+                    b.Property<bool>("AutoDelete")
+                        .HasColumnType("boolean")
+                        .HasColumnName("auto_delete");
+
+                    b.Property<DateTime>("BanTime")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("ban_time");
+
+                    b.Property<Guid?>("BanningAdmin")
+                        .HasColumnType("uuid")
+                        .HasColumnName("banning_admin");
+
+                    b.Property<int>("ExemptFlags")
+                        .HasColumnType("integer")
+                        .HasColumnName("exempt_flags");
+
+                    b.Property<DateTime?>("ExpirationTime")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("expiration_time");
+
+                    b.Property<bool>("Hidden")
+                        .HasColumnType("boolean")
+                        .HasColumnName("hidden");
+
+                    b.Property<DateTime?>("LastEditedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("last_edited_at");
+
+                    b.Property<Guid?>("LastEditedById")
+                        .HasColumnType("uuid")
+                        .HasColumnName("last_edited_by_id");
+
+                    b.Property<Guid?>("PlayerUserId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("player_user_id");
+
+                    b.Property<TimeSpan>("PlaytimeAtNote")
+                        .HasColumnType("interval")
+                        .HasColumnName("playtime_at_note");
+
+                    b.Property<string>("Reason")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("reason");
+
+                    b.Property<int?>("RoundId")
+                        .HasColumnType("integer")
+                        .HasColumnName("round_id");
+
+                    b.Property<int>("Severity")
+                        .HasColumnType("integer")
+                        .HasColumnName("severity");
+
+                    b.HasKey("Id")
+                        .HasName("PK_server_ban");
+
+                    b.HasIndex("Address");
+
+                    b.HasIndex("BanningAdmin");
+
+                    b.HasIndex("LastEditedById");
+
+                    b.HasIndex("PlayerUserId")
+                        .HasDatabaseName("IX_server_ban_player_user_id");
+
+                    b.HasIndex("RoundId")
+                        .HasDatabaseName("IX_server_ban_round_id");
+
+                    b.ToTable("server_ban", null, t =>
+                        {
+                            t.HasCheckConstraint("AddressNotIPv6MappedIPv4", "NOT inet '::ffff:0.0.0.0/96' >>= address");
+
+                            t.HasCheckConstraint("HaveEitherAddressOrUserIdOrHWId", "address IS NOT NULL OR player_user_id IS NOT NULL OR hwid IS NOT NULL");
+                        });
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerBanExemption", b =>
+                {
+                    b.Property<Guid>("UserId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid")
+                        .HasColumnName("user_id");
+
+                    b.Property<int>("Flags")
+                        .HasColumnType("integer")
+                        .HasColumnName("flags");
+
+                    b.HasKey("UserId")
+                        .HasName("PK_server_ban_exemption");
+
+                    b.ToTable("server_ban_exemption", null, t =>
+                        {
+                            t.HasCheckConstraint("FlagsNotZero", "flags != 0");
+                        });
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerBanHit", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("server_ban_hit_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("BanId")
+                        .HasColumnType("integer")
+                        .HasColumnName("ban_id");
+
+                    b.Property<int>("ConnectionId")
+                        .HasColumnType("integer")
+                        .HasColumnName("connection_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_server_ban_hit");
+
+                    b.HasIndex("BanId")
+                        .HasDatabaseName("IX_server_ban_hit_ban_id");
+
+                    b.HasIndex("ConnectionId")
+                        .HasDatabaseName("IX_server_ban_hit_connection_id");
+
+                    b.ToTable("server_ban_hit", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerRoleBan", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("server_role_ban_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<NpgsqlInet?>("Address")
+                        .HasColumnType("inet")
+                        .HasColumnName("address");
+
+                    b.Property<DateTime>("BanTime")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("ban_time");
+
+                    b.Property<Guid?>("BanningAdmin")
+                        .HasColumnType("uuid")
+                        .HasColumnName("banning_admin");
+
+                    b.Property<DateTime?>("ExpirationTime")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("expiration_time");
+
+                    b.Property<bool>("Hidden")
+                        .HasColumnType("boolean")
+                        .HasColumnName("hidden");
+
+                    b.Property<DateTime?>("LastEditedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("last_edited_at");
+
+                    b.Property<Guid?>("LastEditedById")
+                        .HasColumnType("uuid")
+                        .HasColumnName("last_edited_by_id");
+
+                    b.Property<Guid?>("PlayerUserId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("player_user_id");
+
+                    b.Property<TimeSpan>("PlaytimeAtNote")
+                        .HasColumnType("interval")
+                        .HasColumnName("playtime_at_note");
+
+                    b.Property<string>("Reason")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("reason");
+
+                    b.Property<string>("RoleId")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("role_id");
+
+                    b.Property<int?>("RoundId")
+                        .HasColumnType("integer")
+                        .HasColumnName("round_id");
+
+                    b.Property<int>("Severity")
+                        .HasColumnType("integer")
+                        .HasColumnName("severity");
+
+                    b.HasKey("Id")
+                        .HasName("PK_server_role_ban");
+
+                    b.HasIndex("Address");
+
+                    b.HasIndex("BanningAdmin");
+
+                    b.HasIndex("LastEditedById");
+
+                    b.HasIndex("PlayerUserId")
+                        .HasDatabaseName("IX_server_role_ban_player_user_id");
+
+                    b.HasIndex("RoundId")
+                        .HasDatabaseName("IX_server_role_ban_round_id");
+
+                    b.ToTable("server_role_ban", null, t =>
+                        {
+                            t.HasCheckConstraint("AddressNotIPv6MappedIPv4", "NOT inet '::ffff:0.0.0.0/96' >>= address");
+
+                            t.HasCheckConstraint("HaveEitherAddressOrUserIdOrHWId", "address IS NOT NULL OR player_user_id IS NOT NULL OR hwid IS NOT NULL");
+                        });
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerRoleUnban", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("role_unban_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("BanId")
+                        .HasColumnType("integer")
+                        .HasColumnName("ban_id");
+
+                    b.Property<DateTime>("UnbanTime")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("unban_time");
+
+                    b.Property<Guid?>("UnbanningAdmin")
+                        .HasColumnType("uuid")
+                        .HasColumnName("unbanning_admin");
+
+                    b.HasKey("Id")
+                        .HasName("PK_server_role_unban");
+
+                    b.HasIndex("BanId")
+                        .IsUnique();
+
+                    b.ToTable("server_role_unban", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerUnban", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("unban_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("BanId")
+                        .HasColumnType("integer")
+                        .HasColumnName("ban_id");
+
+                    b.Property<DateTime>("UnbanTime")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("unban_time");
+
+                    b.Property<Guid?>("UnbanningAdmin")
+                        .HasColumnType("uuid")
+                        .HasColumnName("unbanning_admin");
+
+                    b.HasKey("Id")
+                        .HasName("PK_server_unban");
+
+                    b.HasIndex("BanId")
+                        .IsUnique();
+
+                    b.ToTable("server_unban", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Trait", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("trait_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ProfileId")
+                        .HasColumnType("integer")
+                        .HasColumnName("profile_id");
+
+                    b.Property<string>("TraitName")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("trait_name");
+
+                    b.HasKey("Id")
+                        .HasName("PK_trait");
+
+                    b.HasIndex("ProfileId", "TraitName")
+                        .IsUnique();
+
+                    b.ToTable("trait", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.UploadedResourceLog", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("uploaded_resource_log_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<byte[]>("Data")
+                        .IsRequired()
+                        .HasColumnType("bytea")
+                        .HasColumnName("data");
+
+                    b.Property<DateTime>("Date")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("date");
+
+                    b.Property<string>("Path")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("path");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("user_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_uploaded_resource_log");
+
+                    b.ToTable("uploaded_resource_log", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Whitelist", b =>
+                {
+                    b.Property<Guid>("UserId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid")
+                        .HasColumnName("user_id");
+
+                    b.HasKey("UserId")
+                        .HasName("PK_whitelist");
+
+                    b.ToTable("whitelist", (string)null);
+                });
+
+            modelBuilder.Entity("PlayerRound", b =>
+                {
+                    b.Property<int>("PlayersId")
+                        .HasColumnType("integer")
+                        .HasColumnName("players_id");
+
+                    b.Property<int>("RoundsId")
+                        .HasColumnType("integer")
+                        .HasColumnName("rounds_id");
+
+                    b.HasKey("PlayersId", "RoundsId")
+                        .HasName("PK_player_round");
+
+                    b.HasIndex("RoundsId")
+                        .HasDatabaseName("IX_player_round_rounds_id");
+
+                    b.ToTable("player_round", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Admin", b =>
+                {
+                    b.HasOne("Content.Server.Database.AdminRank", "AdminRank")
+                        .WithMany("Admins")
+                        .HasForeignKey("AdminRankId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .HasConstraintName("FK_admin_admin_rank_admin_rank_id");
+
+                    b.Navigation("AdminRank");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminFlag", b =>
+                {
+                    b.HasOne("Content.Server.Database.Admin", "Admin")
+                        .WithMany("Flags")
+                        .HasForeignKey("AdminId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_admin_flag_admin_admin_id");
+
+                    b.Navigation("Admin");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminLog", b =>
+                {
+                    b.HasOne("Content.Server.Database.Round", "Round")
+                        .WithMany("AdminLogs")
+                        .HasForeignKey("RoundId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_admin_log_round_round_id");
+
+                    b.Navigation("Round");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminLogPlayer", b =>
+                {
+                    b.HasOne("Content.Server.Database.Player", "Player")
+                        .WithMany("AdminLogs")
+                        .HasForeignKey("PlayerUserId")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_admin_log_player_player_player_user_id");
+
+                    b.HasOne("Content.Server.Database.AdminLog", "Log")
+                        .WithMany("Players")
+                        .HasForeignKey("RoundId", "LogId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_admin_log_player_admin_log_round_id_log_id");
+
+                    b.Navigation("Log");
+
+                    b.Navigation("Player");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminMessage", b =>
+                {
+                    b.HasOne("Content.Server.Database.Player", "CreatedBy")
+                        .WithMany("AdminMessagesCreated")
+                        .HasForeignKey("CreatedById")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .HasConstraintName("FK_admin_messages_player_created_by_id");
+
+                    b.HasOne("Content.Server.Database.Player", "DeletedBy")
+                        .WithMany("AdminMessagesDeleted")
+                        .HasForeignKey("DeletedById")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .HasConstraintName("FK_admin_messages_player_deleted_by_id");
+
+                    b.HasOne("Content.Server.Database.Player", "LastEditedBy")
+                        .WithMany("AdminMessagesLastEdited")
+                        .HasForeignKey("LastEditedById")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .HasConstraintName("FK_admin_messages_player_last_edited_by_id");
+
+                    b.HasOne("Content.Server.Database.Player", "Player")
+                        .WithMany("AdminMessagesReceived")
+                        .HasForeignKey("PlayerUserId")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .HasConstraintName("FK_admin_messages_player_player_user_id");
+
+                    b.HasOne("Content.Server.Database.Round", "Round")
+                        .WithMany()
+                        .HasForeignKey("RoundId")
+                        .HasConstraintName("FK_admin_messages_round_round_id");
+
+                    b.Navigation("CreatedBy");
+
+                    b.Navigation("DeletedBy");
+
+                    b.Navigation("LastEditedBy");
+
+                    b.Navigation("Player");
+
+                    b.Navigation("Round");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminNote", b =>
+                {
+                    b.HasOne("Content.Server.Database.Player", "CreatedBy")
+                        .WithMany("AdminNotesCreated")
+                        .HasForeignKey("CreatedById")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .HasConstraintName("FK_admin_notes_player_created_by_id");
+
+                    b.HasOne("Content.Server.Database.Player", "DeletedBy")
+                        .WithMany("AdminNotesDeleted")
+                        .HasForeignKey("DeletedById")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .HasConstraintName("FK_admin_notes_player_deleted_by_id");
+
+                    b.HasOne("Content.Server.Database.Player", "LastEditedBy")
+                        .WithMany("AdminNotesLastEdited")
+                        .HasForeignKey("LastEditedById")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .HasConstraintName("FK_admin_notes_player_last_edited_by_id");
+
+                    b.HasOne("Content.Server.Database.Player", "Player")
+                        .WithMany("AdminNotesReceived")
+                        .HasForeignKey("PlayerUserId")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .HasConstraintName("FK_admin_notes_player_player_user_id");
+
+                    b.HasOne("Content.Server.Database.Round", "Round")
+                        .WithMany()
+                        .HasForeignKey("RoundId")
+                        .HasConstraintName("FK_admin_notes_round_round_id");
+
+                    b.Navigation("CreatedBy");
+
+                    b.Navigation("DeletedBy");
+
+                    b.Navigation("LastEditedBy");
+
+                    b.Navigation("Player");
+
+                    b.Navigation("Round");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminRankFlag", b =>
+                {
+                    b.HasOne("Content.Server.Database.AdminRank", "Rank")
+                        .WithMany("Flags")
+                        .HasForeignKey("AdminRankId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_admin_rank_flag_admin_rank_admin_rank_id");
+
+                    b.Navigation("Rank");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminWatchlist", b =>
+                {
+                    b.HasOne("Content.Server.Database.Player", "CreatedBy")
+                        .WithMany("AdminWatchlistsCreated")
+                        .HasForeignKey("CreatedById")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .HasConstraintName("FK_admin_watchlists_player_created_by_id");
+
+                    b.HasOne("Content.Server.Database.Player", "DeletedBy")
+                        .WithMany("AdminWatchlistsDeleted")
+                        .HasForeignKey("DeletedById")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .HasConstraintName("FK_admin_watchlists_player_deleted_by_id");
+
+                    b.HasOne("Content.Server.Database.Player", "LastEditedBy")
+                        .WithMany("AdminWatchlistsLastEdited")
+                        .HasForeignKey("LastEditedById")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .HasConstraintName("FK_admin_watchlists_player_last_edited_by_id");
+
+                    b.HasOne("Content.Server.Database.Player", "Player")
+                        .WithMany("AdminWatchlistsReceived")
+                        .HasForeignKey("PlayerUserId")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .HasConstraintName("FK_admin_watchlists_player_player_user_id");
+
+                    b.HasOne("Content.Server.Database.Round", "Round")
+                        .WithMany()
+                        .HasForeignKey("RoundId")
+                        .HasConstraintName("FK_admin_watchlists_round_round_id");
+
+                    b.Navigation("CreatedBy");
+
+                    b.Navigation("DeletedBy");
+
+                    b.Navigation("LastEditedBy");
+
+                    b.Navigation("Player");
+
+                    b.Navigation("Round");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Antag", b =>
+                {
+                    b.HasOne("Content.Server.Database.Profile", "Profile")
+                        .WithMany("Antags")
+                        .HasForeignKey("ProfileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_antag_profile_profile_id");
+
+                    b.Navigation("Profile");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.CDModel+CDProfile", b =>
+                {
+                    b.HasOne("Content.Server.Database.Profile", "Profile")
+                        .WithOne("CDProfile")
+                        .HasForeignKey("Content.Server.Database.CDModel+CDProfile", "ProfileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_cdprofile_profile_profile_id");
+
+                    b.Navigation("Profile");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.CDModel+CharacterRecordEntry", b =>
+                {
+                    b.HasOne("Content.Server.Database.CDModel+CDProfile", "CDProfile")
+                        .WithMany("CharacterRecordEntries")
+                        .HasForeignKey("CDProfileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_cd_character_record_entries_cdprofile_cdprofile_id");
+
+                    b.Navigation("CDProfile");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ConnectionLog", b =>
+                {
+                    b.HasOne("Content.Server.Database.Server", "Server")
+                        .WithMany("ConnectionLogs")
+                        .HasForeignKey("ServerId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .IsRequired()
+                        .HasConstraintName("FK_connection_log_server_server_id");
+
+                    b.OwnsOne("Content.Server.Database.TypedHwid", "HWId", b1 =>
+                        {
+                            b1.Property<int>("ConnectionLogId")
+                                .HasColumnType("integer")
+                                .HasColumnName("connection_log_id");
+
+                            b1.Property<byte[]>("Hwid")
+                                .IsRequired()
+                                .HasColumnType("bytea")
+                                .HasColumnName("hwid");
+
+                            b1.Property<int>("Type")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("integer")
+                                .HasDefaultValue(0)
+                                .HasColumnName("hwid_type");
+
+                            b1.HasKey("ConnectionLogId");
+
+                            b1.ToTable("connection_log");
+
+                            b1.WithOwner()
+                                .HasForeignKey("ConnectionLogId")
+                                .HasConstraintName("FK_connection_log_connection_log_connection_log_id");
+                        });
+
+                    b.Navigation("HWId");
+
+                    b.Navigation("Server");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Job", b =>
+                {
+                    b.HasOne("Content.Server.Database.Profile", "Profile")
+                        .WithMany("Jobs")
+                        .HasForeignKey("ProfileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_job_profile_profile_id");
+
+                    b.Navigation("Profile");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Player", b =>
+                {
+                    b.OwnsOne("Content.Server.Database.TypedHwid", "LastSeenHWId", b1 =>
+                        {
+                            b1.Property<int>("PlayerId")
+                                .HasColumnType("integer")
+                                .HasColumnName("player_id");
+
+                            b1.Property<byte[]>("Hwid")
+                                .IsRequired()
+                                .HasColumnType("bytea")
+                                .HasColumnName("last_seen_hwid");
+
+                            b1.Property<int>("Type")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("integer")
+                                .HasDefaultValue(0)
+                                .HasColumnName("last_seen_hwid_type");
+
+                            b1.HasKey("PlayerId");
+
+                            b1.ToTable("player");
+
+                            b1.WithOwner()
+                                .HasForeignKey("PlayerId")
+                                .HasConstraintName("FK_player_player_player_id");
+                        });
+
+                    b.Navigation("LastSeenHWId");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Profile", b =>
+                {
+                    b.HasOne("Content.Server.Database.Preference", "Preference")
+                        .WithMany("Profiles")
+                        .HasForeignKey("PreferenceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_profile_preference_preference_id");
+
+                    b.Navigation("Preference");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ProfileLoadout", b =>
+                {
+                    b.HasOne("Content.Server.Database.ProfileLoadoutGroup", "ProfileLoadoutGroup")
+                        .WithMany("Loadouts")
+                        .HasForeignKey("ProfileLoadoutGroupId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_profile_loadout_profile_loadout_group_profile_loadout_group~");
+
+                    b.Navigation("ProfileLoadoutGroup");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ProfileLoadoutGroup", b =>
+                {
+                    b.HasOne("Content.Server.Database.ProfileRoleLoadout", "ProfileRoleLoadout")
+                        .WithMany("Groups")
+                        .HasForeignKey("ProfileRoleLoadoutId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_profile_loadout_group_profile_role_loadout_profile_role_loa~");
+
+                    b.Navigation("ProfileRoleLoadout");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ProfileRoleLoadout", b =>
+                {
+                    b.HasOne("Content.Server.Database.Profile", "Profile")
+                        .WithMany("Loadouts")
+                        .HasForeignKey("ProfileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_profile_role_loadout_profile_profile_id");
+
+                    b.Navigation("Profile");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.RoleWhitelist", b =>
+                {
+                    b.HasOne("Content.Server.Database.Player", "Player")
+                        .WithMany("JobWhitelists")
+                        .HasForeignKey("PlayerUserId")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_role_whitelists_player_player_user_id");
+
+                    b.Navigation("Player");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Round", b =>
+                {
+                    b.HasOne("Content.Server.Database.Server", "Server")
+                        .WithMany("Rounds")
+                        .HasForeignKey("ServerId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_round_server_server_id");
+
+                    b.Navigation("Server");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerBan", b =>
+                {
+                    b.HasOne("Content.Server.Database.Player", "CreatedBy")
+                        .WithMany("AdminServerBansCreated")
+                        .HasForeignKey("BanningAdmin")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .HasConstraintName("FK_server_ban_player_banning_admin");
+
+                    b.HasOne("Content.Server.Database.Player", "LastEditedBy")
+                        .WithMany("AdminServerBansLastEdited")
+                        .HasForeignKey("LastEditedById")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .HasConstraintName("FK_server_ban_player_last_edited_by_id");
+
+                    b.HasOne("Content.Server.Database.Round", "Round")
+                        .WithMany()
+                        .HasForeignKey("RoundId")
+                        .HasConstraintName("FK_server_ban_round_round_id");
+
+                    b.OwnsOne("Content.Server.Database.TypedHwid", "HWId", b1 =>
+                        {
+                            b1.Property<int>("ServerBanId")
+                                .HasColumnType("integer")
+                                .HasColumnName("server_ban_id");
+
+                            b1.Property<byte[]>("Hwid")
+                                .IsRequired()
+                                .HasColumnType("bytea")
+                                .HasColumnName("hwid");
+
+                            b1.Property<int>("Type")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("integer")
+                                .HasDefaultValue(0)
+                                .HasColumnName("hwid_type");
+
+                            b1.HasKey("ServerBanId");
+
+                            b1.ToTable("server_ban");
+
+                            b1.WithOwner()
+                                .HasForeignKey("ServerBanId")
+                                .HasConstraintName("FK_server_ban_server_ban_server_ban_id");
+                        });
+
+                    b.Navigation("CreatedBy");
+
+                    b.Navigation("HWId");
+
+                    b.Navigation("LastEditedBy");
+
+                    b.Navigation("Round");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerBanHit", b =>
+                {
+                    b.HasOne("Content.Server.Database.ServerBan", "Ban")
+                        .WithMany("BanHits")
+                        .HasForeignKey("BanId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_server_ban_hit_server_ban_ban_id");
+
+                    b.HasOne("Content.Server.Database.ConnectionLog", "Connection")
+                        .WithMany("BanHits")
+                        .HasForeignKey("ConnectionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_server_ban_hit_connection_log_connection_id");
+
+                    b.Navigation("Ban");
+
+                    b.Navigation("Connection");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerRoleBan", b =>
+                {
+                    b.HasOne("Content.Server.Database.Player", "CreatedBy")
+                        .WithMany("AdminServerRoleBansCreated")
+                        .HasForeignKey("BanningAdmin")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .HasConstraintName("FK_server_role_ban_player_banning_admin");
+
+                    b.HasOne("Content.Server.Database.Player", "LastEditedBy")
+                        .WithMany("AdminServerRoleBansLastEdited")
+                        .HasForeignKey("LastEditedById")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .HasConstraintName("FK_server_role_ban_player_last_edited_by_id");
+
+                    b.HasOne("Content.Server.Database.Round", "Round")
+                        .WithMany()
+                        .HasForeignKey("RoundId")
+                        .HasConstraintName("FK_server_role_ban_round_round_id");
+
+                    b.OwnsOne("Content.Server.Database.TypedHwid", "HWId", b1 =>
+                        {
+                            b1.Property<int>("ServerRoleBanId")
+                                .HasColumnType("integer")
+                                .HasColumnName("server_role_ban_id");
+
+                            b1.Property<byte[]>("Hwid")
+                                .IsRequired()
+                                .HasColumnType("bytea")
+                                .HasColumnName("hwid");
+
+                            b1.Property<int>("Type")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("integer")
+                                .HasDefaultValue(0)
+                                .HasColumnName("hwid_type");
+
+                            b1.HasKey("ServerRoleBanId");
+
+                            b1.ToTable("server_role_ban");
+
+                            b1.WithOwner()
+                                .HasForeignKey("ServerRoleBanId")
+                                .HasConstraintName("FK_server_role_ban_server_role_ban_server_role_ban_id");
+                        });
+
+                    b.Navigation("CreatedBy");
+
+                    b.Navigation("HWId");
+
+                    b.Navigation("LastEditedBy");
+
+                    b.Navigation("Round");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerRoleUnban", b =>
+                {
+                    b.HasOne("Content.Server.Database.ServerRoleBan", "Ban")
+                        .WithOne("Unban")
+                        .HasForeignKey("Content.Server.Database.ServerRoleUnban", "BanId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_server_role_unban_server_role_ban_ban_id");
+
+                    b.Navigation("Ban");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerUnban", b =>
+                {
+                    b.HasOne("Content.Server.Database.ServerBan", "Ban")
+                        .WithOne("Unban")
+                        .HasForeignKey("Content.Server.Database.ServerUnban", "BanId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_server_unban_server_ban_ban_id");
+
+                    b.Navigation("Ban");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Trait", b =>
+                {
+                    b.HasOne("Content.Server.Database.Profile", "Profile")
+                        .WithMany("Traits")
+                        .HasForeignKey("ProfileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_trait_profile_profile_id");
+
+                    b.Navigation("Profile");
+                });
+
+            modelBuilder.Entity("PlayerRound", b =>
+                {
+                    b.HasOne("Content.Server.Database.Player", null)
+                        .WithMany()
+                        .HasForeignKey("PlayersId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_player_round_player_players_id");
+
+                    b.HasOne("Content.Server.Database.Round", null)
+                        .WithMany()
+                        .HasForeignKey("RoundsId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_player_round_round_rounds_id");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Admin", b =>
+                {
+                    b.Navigation("Flags");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminLog", b =>
+                {
+                    b.Navigation("Players");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminRank", b =>
+                {
+                    b.Navigation("Admins");
+
+                    b.Navigation("Flags");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.CDModel+CDProfile", b =>
+                {
+                    b.Navigation("CharacterRecordEntries");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ConnectionLog", b =>
+                {
+                    b.Navigation("BanHits");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Player", b =>
+                {
+                    b.Navigation("AdminLogs");
+
+                    b.Navigation("AdminMessagesCreated");
+
+                    b.Navigation("AdminMessagesDeleted");
+
+                    b.Navigation("AdminMessagesLastEdited");
+
+                    b.Navigation("AdminMessagesReceived");
+
+                    b.Navigation("AdminNotesCreated");
+
+                    b.Navigation("AdminNotesDeleted");
+
+                    b.Navigation("AdminNotesLastEdited");
+
+                    b.Navigation("AdminNotesReceived");
+
+                    b.Navigation("AdminServerBansCreated");
+
+                    b.Navigation("AdminServerBansLastEdited");
+
+                    b.Navigation("AdminServerRoleBansCreated");
+
+                    b.Navigation("AdminServerRoleBansLastEdited");
+
+                    b.Navigation("AdminWatchlistsCreated");
+
+                    b.Navigation("AdminWatchlistsDeleted");
+
+                    b.Navigation("AdminWatchlistsLastEdited");
+
+                    b.Navigation("AdminWatchlistsReceived");
+
+                    b.Navigation("JobWhitelists");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Preference", b =>
+                {
+                    b.Navigation("Profiles");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Profile", b =>
+                {
+                    b.Navigation("Antags");
+
+                    b.Navigation("CDProfile");
+
+                    b.Navigation("Jobs");
+
+                    b.Navigation("Loadouts");
+
+                    b.Navigation("Traits");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ProfileLoadoutGroup", b =>
+                {
+                    b.Navigation("Loadouts");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ProfileRoleLoadout", b =>
+                {
+                    b.Navigation("Groups");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Round", b =>
+                {
+                    b.Navigation("AdminLogs");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Server", b =>
+                {
+                    b.Navigation("ConnectionLogs");
+
+                    b.Navigation("Rounds");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerBan", b =>
+                {
+                    b.Navigation("BanHits");
+
+                    b.Navigation("Unban");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerRoleBan", b =>
+                {
+                    b.Navigation("Unban");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/Content.Server.Database/Migrations/Postgres/20250303043202_CosmaticDriftCharacterRecords.cs b/Content.Server.Database/Migrations/Postgres/20250303043202_CosmaticDriftCharacterRecords.cs
new file mode 100644
index 0000000000..21c07ca35c
--- /dev/null
+++ b/Content.Server.Database/Migrations/Postgres/20250303043202_CosmaticDriftCharacterRecords.cs
@@ -0,0 +1,86 @@
+using System.Text.Json;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace Content.Server.Database.Migrations.Postgres
+{
+    /// <inheritdoc />
+    public partial class CosmaticDriftCharacterRecords : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "cdprofile",
+                columns: table => new
+                {
+                    cdprofile_id = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    profile_id = table.Column<int>(type: "integer", nullable: false),
+                    height = table.Column<float>(type: "real", nullable: false),
+                    character_records = table.Column<JsonDocument>(type: "jsonb", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_cdprofile", x => x.cdprofile_id);
+                    table.ForeignKey(
+                        name: "FK_cdprofile_profile_profile_id",
+                        column: x => x.profile_id,
+                        principalTable: "profile",
+                        principalColumn: "profile_id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "cd_character_record_entries",
+                columns: table => new
+                {
+                    cd_character_record_entries_id = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    title = table.Column<string>(type: "text", nullable: false),
+                    involved = table.Column<string>(type: "text", nullable: false),
+                    description = table.Column<string>(type: "text", nullable: false),
+                    type = table.Column<byte>(type: "smallint", nullable: false),
+                    cdprofile_id = table.Column<int>(type: "integer", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_cd_character_record_entries", x => x.cd_character_record_entries_id);
+                    table.ForeignKey(
+                        name: "FK_cd_character_record_entries_cdprofile_cdprofile_id",
+                        column: x => x.cdprofile_id,
+                        principalTable: "cdprofile",
+                        principalColumn: "cdprofile_id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_cd_character_record_entries_cd_character_record_entries_id",
+                table: "cd_character_record_entries",
+                column: "cd_character_record_entries_id");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_cd_character_record_entries_cdprofile_id",
+                table: "cd_character_record_entries",
+                column: "cdprofile_id");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_cdprofile_profile_id",
+                table: "cdprofile",
+                column: "profile_id",
+                unique: true);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "cd_character_record_entries");
+
+            migrationBuilder.DropTable(
+                name: "cdprofile");
+        }
+    }
+}
diff --git a/Content.Server.Database/Migrations/Postgres/PostgresServerDbContextModelSnapshot.cs b/Content.Server.Database/Migrations/Postgres/PostgresServerDbContextModelSnapshot.cs
index a8744fcd65..179740ee98 100644
--- a/Content.Server.Database/Migrations/Postgres/PostgresServerDbContextModelSnapshot.cs
+++ b/Content.Server.Database/Migrations/Postgres/PostgresServerDbContextModelSnapshot.cs
@@ -578,6 +578,79 @@ namespace Content.Server.Database.Migrations.Postgres
                     b.ToTable("blacklist", (string)null);
                 });
 
+            modelBuilder.Entity("Content.Server.Database.CDModel+CDProfile", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("cdprofile_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<JsonDocument>("CharacterRecords")
+                        .HasColumnType("jsonb")
+                        .HasColumnName("character_records");
+
+                    b.Property<float>("Height")
+                        .HasColumnType("real")
+                        .HasColumnName("height");
+
+                    b.Property<int>("ProfileId")
+                        .HasColumnType("integer")
+                        .HasColumnName("profile_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_cdprofile");
+
+                    b.HasIndex("ProfileId")
+                        .IsUnique();
+
+                    b.ToTable("cdprofile", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.CDModel+CharacterRecordEntry", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("cd_character_record_entries_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("CDProfileId")
+                        .HasColumnType("integer")
+                        .HasColumnName("cdprofile_id");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("description");
+
+                    b.Property<string>("Involved")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("involved");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("title");
+
+                    b.Property<byte>("Type")
+                        .HasColumnType("smallint")
+                        .HasColumnName("type");
+
+                    b.HasKey("Id")
+                        .HasName("PK_cd_character_record_entries");
+
+                    b.HasIndex("CDProfileId");
+
+                    b.HasIndex("Id")
+                        .HasDatabaseName("IX_cd_character_record_entries_cd_character_record_entries_id");
+
+                    b.ToTable("cd_character_record_entries", (string)null);
+                });
+
             modelBuilder.Entity("Content.Server.Database.ConnectionLog", b =>
                 {
                     b.Property<int>("Id")
@@ -1656,6 +1729,30 @@ namespace Content.Server.Database.Migrations.Postgres
                     b.Navigation("Profile");
                 });
 
+            modelBuilder.Entity("Content.Server.Database.CDModel+CDProfile", b =>
+                {
+                    b.HasOne("Content.Server.Database.Profile", "Profile")
+                        .WithOne("CDProfile")
+                        .HasForeignKey("Content.Server.Database.CDModel+CDProfile", "ProfileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_cdprofile_profile_profile_id");
+
+                    b.Navigation("Profile");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.CDModel+CharacterRecordEntry", b =>
+                {
+                    b.HasOne("Content.Server.Database.CDModel+CDProfile", "CDProfile")
+                        .WithMany("CharacterRecordEntries")
+                        .HasForeignKey("CDProfileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_cd_character_record_entries_cdprofile_cdprofile_id");
+
+                    b.Navigation("CDProfile");
+                });
+
             modelBuilder.Entity("Content.Server.Database.ConnectionLog", b =>
                 {
                     b.HasOne("Content.Server.Database.Server", "Server")
@@ -2015,6 +2112,11 @@ namespace Content.Server.Database.Migrations.Postgres
                     b.Navigation("Flags");
                 });
 
+            modelBuilder.Entity("Content.Server.Database.CDModel+CDProfile", b =>
+                {
+                    b.Navigation("CharacterRecordEntries");
+                });
+
             modelBuilder.Entity("Content.Server.Database.ConnectionLog", b =>
                 {
                     b.Navigation("BanHits");
@@ -2068,6 +2170,8 @@ namespace Content.Server.Database.Migrations.Postgres
                 {
                     b.Navigation("Antags");
 
+                    b.Navigation("CDProfile");
+
                     b.Navigation("Jobs");
 
                     b.Navigation("Loadouts");
diff --git a/Content.Server.Database/Migrations/Sqlite/20250303043130_CosmaticDriftCharacterRecords.Designer.cs b/Content.Server.Database/Migrations/Sqlite/20250303043130_CosmaticDriftCharacterRecords.Designer.cs
new file mode 100644
index 0000000000..6c0f3e47ff
--- /dev/null
+++ b/Content.Server.Database/Migrations/Sqlite/20250303043130_CosmaticDriftCharacterRecords.Designer.cs
@@ -0,0 +1,2137 @@
+// <auto-generated />
+using System;
+using Content.Server.Database;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace Content.Server.Database.Migrations.Sqlite
+{
+    [DbContext(typeof(SqliteServerDbContext))]
+    [Migration("20250303043130_CosmaticDriftCharacterRecords")]
+    partial class CosmaticDriftCharacterRecords
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder.HasAnnotation("ProductVersion", "8.0.0");
+
+            modelBuilder.Entity("Content.Server.Database.Admin", b =>
+                {
+                    b.Property<Guid>("UserId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("user_id");
+
+                    b.Property<int?>("AdminRankId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("admin_rank_id");
+
+                    b.Property<bool>("Deadminned")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("deadminned");
+
+                    b.Property<bool>("Suspended")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("suspended");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("title");
+
+                    b.HasKey("UserId")
+                        .HasName("PK_admin");
+
+                    b.HasIndex("AdminRankId")
+                        .HasDatabaseName("IX_admin_admin_rank_id");
+
+                    b.ToTable("admin", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminFlag", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("admin_flag_id");
+
+                    b.Property<Guid>("AdminId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("admin_id");
+
+                    b.Property<string>("Flag")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("flag");
+
+                    b.Property<bool>("Negative")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("negative");
+
+                    b.HasKey("Id")
+                        .HasName("PK_admin_flag");
+
+                    b.HasIndex("AdminId")
+                        .HasDatabaseName("IX_admin_flag_admin_id");
+
+                    b.HasIndex("Flag", "AdminId")
+                        .IsUnique();
+
+                    b.ToTable("admin_flag", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminLog", b =>
+                {
+                    b.Property<int>("RoundId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("round_id");
+
+                    b.Property<int>("Id")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("admin_log_id");
+
+                    b.Property<DateTime>("Date")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("date");
+
+                    b.Property<sbyte>("Impact")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("impact");
+
+                    b.Property<string>("Json")
+                        .IsRequired()
+                        .HasColumnType("jsonb")
+                        .HasColumnName("json");
+
+                    b.Property<string>("Message")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("message");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("type");
+
+                    b.HasKey("RoundId", "Id")
+                        .HasName("PK_admin_log");
+
+                    b.HasIndex("Date");
+
+                    b.HasIndex("Type")
+                        .HasDatabaseName("IX_admin_log_type");
+
+                    b.ToTable("admin_log", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminLogPlayer", b =>
+                {
+                    b.Property<int>("RoundId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("round_id");
+
+                    b.Property<int>("LogId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("log_id");
+
+                    b.Property<Guid>("PlayerUserId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("player_user_id");
+
+                    b.HasKey("RoundId", "LogId", "PlayerUserId")
+                        .HasName("PK_admin_log_player");
+
+                    b.HasIndex("PlayerUserId")
+                        .HasDatabaseName("IX_admin_log_player_player_user_id");
+
+                    b.ToTable("admin_log_player", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminMessage", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("admin_messages_id");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("created_at");
+
+                    b.Property<Guid?>("CreatedById")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("created_by_id");
+
+                    b.Property<bool>("Deleted")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("deleted");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("deleted_at");
+
+                    b.Property<Guid?>("DeletedById")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("deleted_by_id");
+
+                    b.Property<bool>("Dismissed")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("dismissed");
+
+                    b.Property<DateTime?>("ExpirationTime")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("expiration_time");
+
+                    b.Property<DateTime?>("LastEditedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("last_edited_at");
+
+                    b.Property<Guid?>("LastEditedById")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("last_edited_by_id");
+
+                    b.Property<string>("Message")
+                        .IsRequired()
+                        .HasMaxLength(4096)
+                        .HasColumnType("TEXT")
+                        .HasColumnName("message");
+
+                    b.Property<Guid?>("PlayerUserId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("player_user_id");
+
+                    b.Property<TimeSpan>("PlaytimeAtNote")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("playtime_at_note");
+
+                    b.Property<int?>("RoundId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("round_id");
+
+                    b.Property<bool>("Seen")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("seen");
+
+                    b.HasKey("Id")
+                        .HasName("PK_admin_messages");
+
+                    b.HasIndex("CreatedById");
+
+                    b.HasIndex("DeletedById");
+
+                    b.HasIndex("LastEditedById");
+
+                    b.HasIndex("PlayerUserId")
+                        .HasDatabaseName("IX_admin_messages_player_user_id");
+
+                    b.HasIndex("RoundId")
+                        .HasDatabaseName("IX_admin_messages_round_id");
+
+                    b.ToTable("admin_messages", null, t =>
+                        {
+                            t.HasCheckConstraint("NotDismissedAndSeen", "NOT dismissed OR seen");
+                        });
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminNote", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("admin_notes_id");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("created_at");
+
+                    b.Property<Guid?>("CreatedById")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("created_by_id");
+
+                    b.Property<bool>("Deleted")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("deleted");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("deleted_at");
+
+                    b.Property<Guid?>("DeletedById")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("deleted_by_id");
+
+                    b.Property<DateTime?>("ExpirationTime")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("expiration_time");
+
+                    b.Property<DateTime?>("LastEditedAt")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("last_edited_at");
+
+                    b.Property<Guid?>("LastEditedById")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("last_edited_by_id");
+
+                    b.Property<string>("Message")
+                        .IsRequired()
+                        .HasMaxLength(4096)
+                        .HasColumnType("TEXT")
+                        .HasColumnName("message");
+
+                    b.Property<Guid?>("PlayerUserId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("player_user_id");
+
+                    b.Property<TimeSpan>("PlaytimeAtNote")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("playtime_at_note");
+
+                    b.Property<int?>("RoundId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("round_id");
+
+                    b.Property<bool>("Secret")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("secret");
+
+                    b.Property<int>("Severity")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("severity");
+
+                    b.HasKey("Id")
+                        .HasName("PK_admin_notes");
+
+                    b.HasIndex("CreatedById");
+
+                    b.HasIndex("DeletedById");
+
+                    b.HasIndex("LastEditedById");
+
+                    b.HasIndex("PlayerUserId")
+                        .HasDatabaseName("IX_admin_notes_player_user_id");
+
+                    b.HasIndex("RoundId")
+                        .HasDatabaseName("IX_admin_notes_round_id");
+
+                    b.ToTable("admin_notes", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminRank", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("admin_rank_id");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("name");
+
+                    b.HasKey("Id")
+                        .HasName("PK_admin_rank");
+
+                    b.ToTable("admin_rank", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminRankFlag", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("admin_rank_flag_id");
+
+                    b.Property<int>("AdminRankId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("admin_rank_id");
+
+                    b.Property<string>("Flag")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("flag");
+
+                    b.HasKey("Id")
+                        .HasName("PK_admin_rank_flag");
+
+                    b.HasIndex("AdminRankId");
+
+                    b.HasIndex("Flag", "AdminRankId")
+                        .IsUnique();
+
+                    b.ToTable("admin_rank_flag", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminWatchlist", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("admin_watchlists_id");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("created_at");
+
+                    b.Property<Guid?>("CreatedById")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("created_by_id");
+
+                    b.Property<bool>("Deleted")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("deleted");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("deleted_at");
+
+                    b.Property<Guid?>("DeletedById")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("deleted_by_id");
+
+                    b.Property<DateTime?>("ExpirationTime")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("expiration_time");
+
+                    b.Property<DateTime?>("LastEditedAt")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("last_edited_at");
+
+                    b.Property<Guid?>("LastEditedById")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("last_edited_by_id");
+
+                    b.Property<string>("Message")
+                        .IsRequired()
+                        .HasMaxLength(4096)
+                        .HasColumnType("TEXT")
+                        .HasColumnName("message");
+
+                    b.Property<Guid?>("PlayerUserId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("player_user_id");
+
+                    b.Property<TimeSpan>("PlaytimeAtNote")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("playtime_at_note");
+
+                    b.Property<int?>("RoundId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("round_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_admin_watchlists");
+
+                    b.HasIndex("CreatedById");
+
+                    b.HasIndex("DeletedById");
+
+                    b.HasIndex("LastEditedById");
+
+                    b.HasIndex("PlayerUserId")
+                        .HasDatabaseName("IX_admin_watchlists_player_user_id");
+
+                    b.HasIndex("RoundId")
+                        .HasDatabaseName("IX_admin_watchlists_round_id");
+
+                    b.ToTable("admin_watchlists", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Antag", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("antag_id");
+
+                    b.Property<string>("AntagName")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("antag_name");
+
+                    b.Property<int>("ProfileId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("profile_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_antag");
+
+                    b.HasIndex("ProfileId", "AntagName")
+                        .IsUnique();
+
+                    b.ToTable("antag", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AssignedUserId", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("assigned_user_id_id");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("user_id");
+
+                    b.Property<string>("UserName")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("user_name");
+
+                    b.HasKey("Id")
+                        .HasName("PK_assigned_user_id");
+
+                    b.HasIndex("UserId")
+                        .IsUnique();
+
+                    b.HasIndex("UserName")
+                        .IsUnique();
+
+                    b.ToTable("assigned_user_id", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.BanTemplate", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("ban_template_id");
+
+                    b.Property<bool>("AutoDelete")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("auto_delete");
+
+                    b.Property<int>("ExemptFlags")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("exempt_flags");
+
+                    b.Property<bool>("Hidden")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("hidden");
+
+                    b.Property<TimeSpan>("Length")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("length");
+
+                    b.Property<string>("Reason")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("reason");
+
+                    b.Property<int>("Severity")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("severity");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("title");
+
+                    b.HasKey("Id")
+                        .HasName("PK_ban_template");
+
+                    b.ToTable("ban_template", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Blacklist", b =>
+                {
+                    b.Property<Guid>("UserId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("user_id");
+
+                    b.HasKey("UserId")
+                        .HasName("PK_blacklist");
+
+                    b.ToTable("blacklist", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.CDModel+CDProfile", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("cdprofile_id");
+
+                    b.Property<byte[]>("CharacterRecords")
+                        .HasColumnType("jsonb")
+                        .HasColumnName("character_records");
+
+                    b.Property<float>("Height")
+                        .HasColumnType("REAL")
+                        .HasColumnName("height");
+
+                    b.Property<int>("ProfileId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("profile_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_cdprofile");
+
+                    b.HasIndex("ProfileId")
+                        .IsUnique();
+
+                    b.ToTable("cdprofile", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.CDModel+CharacterRecordEntry", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("cd_character_record_entries_id");
+
+                    b.Property<int>("CDProfileId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("cdprofile_id");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("description");
+
+                    b.Property<string>("Involved")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("involved");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("title");
+
+                    b.Property<byte>("Type")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("type");
+
+                    b.HasKey("Id")
+                        .HasName("PK_cd_character_record_entries");
+
+                    b.HasIndex("CDProfileId")
+                        .HasDatabaseName("IX_cd_character_record_entries_cdprofile_id");
+
+                    b.HasIndex("Id")
+                        .HasDatabaseName("IX_cd_character_record_entries_cd_character_record_entries_id");
+
+                    b.ToTable("cd_character_record_entries", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ConnectionLog", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("connection_log_id");
+
+                    b.Property<string>("Address")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("address");
+
+                    b.Property<byte?>("Denied")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("denied");
+
+                    b.Property<int>("ServerId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(0)
+                        .HasColumnName("server_id");
+
+                    b.Property<DateTime>("Time")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("time");
+
+                    b.Property<float>("Trust")
+                        .HasColumnType("REAL")
+                        .HasColumnName("trust");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("user_id");
+
+                    b.Property<string>("UserName")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("user_name");
+
+                    b.HasKey("Id")
+                        .HasName("PK_connection_log");
+
+                    b.HasIndex("ServerId")
+                        .HasDatabaseName("IX_connection_log_server_id");
+
+                    b.HasIndex("Time");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("connection_log", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.IPIntelCache", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("ipintel_cache_id");
+
+                    b.Property<string>("Address")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("address");
+
+                    b.Property<float>("Score")
+                        .HasColumnType("REAL")
+                        .HasColumnName("score");
+
+                    b.Property<DateTime>("Time")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("time");
+
+                    b.HasKey("Id")
+                        .HasName("PK_ipintel_cache");
+
+                    b.HasIndex("Address")
+                        .IsUnique();
+
+                    b.ToTable("ipintel_cache", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Job", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("job_id");
+
+                    b.Property<string>("JobName")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("job_name");
+
+                    b.Property<int>("Priority")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("priority");
+
+                    b.Property<int>("ProfileId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("profile_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_job");
+
+                    b.HasIndex("ProfileId");
+
+                    b.HasIndex("ProfileId", "JobName")
+                        .IsUnique();
+
+                    b.HasIndex(new[] { "ProfileId" }, "IX_job_one_high_priority")
+                        .IsUnique()
+                        .HasFilter("priority = 3");
+
+                    b.ToTable("job", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.PlayTime", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("play_time_id");
+
+                    b.Property<Guid>("PlayerId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("player_id");
+
+                    b.Property<TimeSpan>("TimeSpent")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("time_spent");
+
+                    b.Property<string>("Tracker")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("tracker");
+
+                    b.HasKey("Id")
+                        .HasName("PK_play_time");
+
+                    b.HasIndex("PlayerId", "Tracker")
+                        .IsUnique();
+
+                    b.ToTable("play_time", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Player", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("player_id");
+
+                    b.Property<DateTime>("FirstSeenTime")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("first_seen_time");
+
+                    b.Property<DateTime?>("LastReadRules")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("last_read_rules");
+
+                    b.Property<string>("LastSeenAddress")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("last_seen_address");
+
+                    b.Property<DateTime>("LastSeenTime")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("last_seen_time");
+
+                    b.Property<string>("LastSeenUserName")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("last_seen_user_name");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("user_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_player");
+
+                    b.HasAlternateKey("UserId")
+                        .HasName("ak_player_user_id");
+
+                    b.HasIndex("LastSeenUserName");
+
+                    b.HasIndex("UserId")
+                        .IsUnique();
+
+                    b.ToTable("player", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Preference", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("preference_id");
+
+                    b.Property<string>("AdminOOCColor")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("admin_ooc_color");
+
+                    b.Property<int>("SelectedCharacterSlot")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("selected_character_slot");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("user_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_preference");
+
+                    b.HasIndex("UserId")
+                        .IsUnique();
+
+                    b.ToTable("preference", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Profile", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("profile_id");
+
+                    b.Property<int>("Age")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("age");
+
+                    b.Property<string>("CharacterName")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("char_name");
+
+                    b.Property<string>("EyeColor")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("eye_color");
+
+                    b.Property<string>("FacialHairColor")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("facial_hair_color");
+
+                    b.Property<string>("FacialHairName")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("facial_hair_name");
+
+                    b.Property<string>("FlavorText")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("flavor_text");
+
+                    b.Property<string>("Gender")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("gender");
+
+                    b.Property<string>("HairColor")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("hair_color");
+
+                    b.Property<string>("HairName")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("hair_name");
+
+                    b.Property<byte[]>("Markings")
+                        .HasColumnType("jsonb")
+                        .HasColumnName("markings");
+
+                    b.Property<int>("PreferenceId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("preference_id");
+
+                    b.Property<int>("PreferenceUnavailable")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("pref_unavailable");
+
+                    b.Property<string>("Sex")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("sex");
+
+                    b.Property<string>("SkinColor")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("skin_color");
+
+                    b.Property<int>("Slot")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("slot");
+
+                    b.Property<int>("SpawnPriority")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("spawn_priority");
+
+                    b.Property<string>("Species")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("species");
+
+                    b.HasKey("Id")
+                        .HasName("PK_profile");
+
+                    b.HasIndex("PreferenceId")
+                        .HasDatabaseName("IX_profile_preference_id");
+
+                    b.HasIndex("Slot", "PreferenceId")
+                        .IsUnique();
+
+                    b.ToTable("profile", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ProfileLoadout", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("profile_loadout_id");
+
+                    b.Property<string>("LoadoutName")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("loadout_name");
+
+                    b.Property<int>("ProfileLoadoutGroupId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("profile_loadout_group_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_profile_loadout");
+
+                    b.HasIndex("ProfileLoadoutGroupId");
+
+                    b.ToTable("profile_loadout", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ProfileLoadoutGroup", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("profile_loadout_group_id");
+
+                    b.Property<string>("GroupName")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("group_name");
+
+                    b.Property<int>("ProfileRoleLoadoutId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("profile_role_loadout_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_profile_loadout_group");
+
+                    b.HasIndex("ProfileRoleLoadoutId");
+
+                    b.ToTable("profile_loadout_group", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ProfileRoleLoadout", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("profile_role_loadout_id");
+
+                    b.Property<int>("ProfileId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("profile_id");
+
+                    b.Property<string>("RoleName")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("role_name");
+
+                    b.HasKey("Id")
+                        .HasName("PK_profile_role_loadout");
+
+                    b.HasIndex("ProfileId");
+
+                    b.ToTable("profile_role_loadout", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.RoleWhitelist", b =>
+                {
+                    b.Property<Guid>("PlayerUserId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("player_user_id");
+
+                    b.Property<string>("RoleId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("role_id");
+
+                    b.HasKey("PlayerUserId", "RoleId")
+                        .HasName("PK_role_whitelists");
+
+                    b.ToTable("role_whitelists", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Round", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("round_id");
+
+                    b.Property<int>("ServerId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("server_id");
+
+                    b.Property<DateTime?>("StartDate")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("start_date");
+
+                    b.HasKey("Id")
+                        .HasName("PK_round");
+
+                    b.HasIndex("ServerId")
+                        .HasDatabaseName("IX_round_server_id");
+
+                    b.HasIndex("StartDate");
+
+                    b.ToTable("round", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Server", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("server_id");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("name");
+
+                    b.HasKey("Id")
+                        .HasName("PK_server");
+
+                    b.ToTable("server", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerBan", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("server_ban_id");
+
+                    b.Property<string>("Address")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("address");
+
+                    b.Property<bool>("AutoDelete")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("auto_delete");
+
+                    b.Property<DateTime>("BanTime")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("ban_time");
+
+                    b.Property<Guid?>("BanningAdmin")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("banning_admin");
+
+                    b.Property<int>("ExemptFlags")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("exempt_flags");
+
+                    b.Property<DateTime?>("ExpirationTime")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("expiration_time");
+
+                    b.Property<bool>("Hidden")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("hidden");
+
+                    b.Property<DateTime?>("LastEditedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("last_edited_at");
+
+                    b.Property<Guid?>("LastEditedById")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("last_edited_by_id");
+
+                    b.Property<Guid?>("PlayerUserId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("player_user_id");
+
+                    b.Property<TimeSpan>("PlaytimeAtNote")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("playtime_at_note");
+
+                    b.Property<string>("Reason")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("reason");
+
+                    b.Property<int?>("RoundId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("round_id");
+
+                    b.Property<int>("Severity")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("severity");
+
+                    b.HasKey("Id")
+                        .HasName("PK_server_ban");
+
+                    b.HasIndex("Address");
+
+                    b.HasIndex("BanningAdmin");
+
+                    b.HasIndex("LastEditedById");
+
+                    b.HasIndex("PlayerUserId")
+                        .HasDatabaseName("IX_server_ban_player_user_id");
+
+                    b.HasIndex("RoundId")
+                        .HasDatabaseName("IX_server_ban_round_id");
+
+                    b.ToTable("server_ban", null, t =>
+                        {
+                            t.HasCheckConstraint("HaveEitherAddressOrUserIdOrHWId", "address IS NOT NULL OR player_user_id IS NOT NULL OR hwid IS NOT NULL");
+                        });
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerBanExemption", b =>
+                {
+                    b.Property<Guid>("UserId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("user_id");
+
+                    b.Property<int>("Flags")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("flags");
+
+                    b.HasKey("UserId")
+                        .HasName("PK_server_ban_exemption");
+
+                    b.ToTable("server_ban_exemption", null, t =>
+                        {
+                            t.HasCheckConstraint("FlagsNotZero", "flags != 0");
+                        });
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerBanHit", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("server_ban_hit_id");
+
+                    b.Property<int>("BanId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("ban_id");
+
+                    b.Property<int>("ConnectionId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("connection_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_server_ban_hit");
+
+                    b.HasIndex("BanId")
+                        .HasDatabaseName("IX_server_ban_hit_ban_id");
+
+                    b.HasIndex("ConnectionId")
+                        .HasDatabaseName("IX_server_ban_hit_connection_id");
+
+                    b.ToTable("server_ban_hit", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerRoleBan", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("server_role_ban_id");
+
+                    b.Property<string>("Address")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("address");
+
+                    b.Property<DateTime>("BanTime")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("ban_time");
+
+                    b.Property<Guid?>("BanningAdmin")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("banning_admin");
+
+                    b.Property<DateTime?>("ExpirationTime")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("expiration_time");
+
+                    b.Property<bool>("Hidden")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("hidden");
+
+                    b.Property<DateTime?>("LastEditedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("last_edited_at");
+
+                    b.Property<Guid?>("LastEditedById")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("last_edited_by_id");
+
+                    b.Property<Guid?>("PlayerUserId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("player_user_id");
+
+                    b.Property<TimeSpan>("PlaytimeAtNote")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("playtime_at_note");
+
+                    b.Property<string>("Reason")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("reason");
+
+                    b.Property<string>("RoleId")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("role_id");
+
+                    b.Property<int?>("RoundId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("round_id");
+
+                    b.Property<int>("Severity")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("severity");
+
+                    b.HasKey("Id")
+                        .HasName("PK_server_role_ban");
+
+                    b.HasIndex("Address");
+
+                    b.HasIndex("BanningAdmin");
+
+                    b.HasIndex("LastEditedById");
+
+                    b.HasIndex("PlayerUserId")
+                        .HasDatabaseName("IX_server_role_ban_player_user_id");
+
+                    b.HasIndex("RoundId")
+                        .HasDatabaseName("IX_server_role_ban_round_id");
+
+                    b.ToTable("server_role_ban", null, t =>
+                        {
+                            t.HasCheckConstraint("HaveEitherAddressOrUserIdOrHWId", "address IS NOT NULL OR player_user_id IS NOT NULL OR hwid IS NOT NULL");
+                        });
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerRoleUnban", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("role_unban_id");
+
+                    b.Property<int>("BanId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("ban_id");
+
+                    b.Property<DateTime>("UnbanTime")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("unban_time");
+
+                    b.Property<Guid?>("UnbanningAdmin")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("unbanning_admin");
+
+                    b.HasKey("Id")
+                        .HasName("PK_server_role_unban");
+
+                    b.HasIndex("BanId")
+                        .IsUnique();
+
+                    b.ToTable("server_role_unban", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerUnban", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("unban_id");
+
+                    b.Property<int>("BanId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("ban_id");
+
+                    b.Property<DateTime>("UnbanTime")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("unban_time");
+
+                    b.Property<Guid?>("UnbanningAdmin")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("unbanning_admin");
+
+                    b.HasKey("Id")
+                        .HasName("PK_server_unban");
+
+                    b.HasIndex("BanId")
+                        .IsUnique();
+
+                    b.ToTable("server_unban", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Trait", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("trait_id");
+
+                    b.Property<int>("ProfileId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("profile_id");
+
+                    b.Property<string>("TraitName")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("trait_name");
+
+                    b.HasKey("Id")
+                        .HasName("PK_trait");
+
+                    b.HasIndex("ProfileId", "TraitName")
+                        .IsUnique();
+
+                    b.ToTable("trait", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.UploadedResourceLog", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("uploaded_resource_log_id");
+
+                    b.Property<byte[]>("Data")
+                        .IsRequired()
+                        .HasColumnType("BLOB")
+                        .HasColumnName("data");
+
+                    b.Property<DateTime>("Date")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("date");
+
+                    b.Property<string>("Path")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("path");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("user_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_uploaded_resource_log");
+
+                    b.ToTable("uploaded_resource_log", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Whitelist", b =>
+                {
+                    b.Property<Guid>("UserId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("user_id");
+
+                    b.HasKey("UserId")
+                        .HasName("PK_whitelist");
+
+                    b.ToTable("whitelist", (string)null);
+                });
+
+            modelBuilder.Entity("PlayerRound", b =>
+                {
+                    b.Property<int>("PlayersId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("players_id");
+
+                    b.Property<int>("RoundsId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("rounds_id");
+
+                    b.HasKey("PlayersId", "RoundsId")
+                        .HasName("PK_player_round");
+
+                    b.HasIndex("RoundsId")
+                        .HasDatabaseName("IX_player_round_rounds_id");
+
+                    b.ToTable("player_round", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Admin", b =>
+                {
+                    b.HasOne("Content.Server.Database.AdminRank", "AdminRank")
+                        .WithMany("Admins")
+                        .HasForeignKey("AdminRankId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .HasConstraintName("FK_admin_admin_rank_admin_rank_id");
+
+                    b.Navigation("AdminRank");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminFlag", b =>
+                {
+                    b.HasOne("Content.Server.Database.Admin", "Admin")
+                        .WithMany("Flags")
+                        .HasForeignKey("AdminId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_admin_flag_admin_admin_id");
+
+                    b.Navigation("Admin");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminLog", b =>
+                {
+                    b.HasOne("Content.Server.Database.Round", "Round")
+                        .WithMany("AdminLogs")
+                        .HasForeignKey("RoundId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_admin_log_round_round_id");
+
+                    b.Navigation("Round");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminLogPlayer", b =>
+                {
+                    b.HasOne("Content.Server.Database.Player", "Player")
+                        .WithMany("AdminLogs")
+                        .HasForeignKey("PlayerUserId")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_admin_log_player_player_player_user_id");
+
+                    b.HasOne("Content.Server.Database.AdminLog", "Log")
+                        .WithMany("Players")
+                        .HasForeignKey("RoundId", "LogId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_admin_log_player_admin_log_round_id_log_id");
+
+                    b.Navigation("Log");
+
+                    b.Navigation("Player");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminMessage", b =>
+                {
+                    b.HasOne("Content.Server.Database.Player", "CreatedBy")
+                        .WithMany("AdminMessagesCreated")
+                        .HasForeignKey("CreatedById")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .HasConstraintName("FK_admin_messages_player_created_by_id");
+
+                    b.HasOne("Content.Server.Database.Player", "DeletedBy")
+                        .WithMany("AdminMessagesDeleted")
+                        .HasForeignKey("DeletedById")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .HasConstraintName("FK_admin_messages_player_deleted_by_id");
+
+                    b.HasOne("Content.Server.Database.Player", "LastEditedBy")
+                        .WithMany("AdminMessagesLastEdited")
+                        .HasForeignKey("LastEditedById")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .HasConstraintName("FK_admin_messages_player_last_edited_by_id");
+
+                    b.HasOne("Content.Server.Database.Player", "Player")
+                        .WithMany("AdminMessagesReceived")
+                        .HasForeignKey("PlayerUserId")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .HasConstraintName("FK_admin_messages_player_player_user_id");
+
+                    b.HasOne("Content.Server.Database.Round", "Round")
+                        .WithMany()
+                        .HasForeignKey("RoundId")
+                        .HasConstraintName("FK_admin_messages_round_round_id");
+
+                    b.Navigation("CreatedBy");
+
+                    b.Navigation("DeletedBy");
+
+                    b.Navigation("LastEditedBy");
+
+                    b.Navigation("Player");
+
+                    b.Navigation("Round");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminNote", b =>
+                {
+                    b.HasOne("Content.Server.Database.Player", "CreatedBy")
+                        .WithMany("AdminNotesCreated")
+                        .HasForeignKey("CreatedById")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .HasConstraintName("FK_admin_notes_player_created_by_id");
+
+                    b.HasOne("Content.Server.Database.Player", "DeletedBy")
+                        .WithMany("AdminNotesDeleted")
+                        .HasForeignKey("DeletedById")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .HasConstraintName("FK_admin_notes_player_deleted_by_id");
+
+                    b.HasOne("Content.Server.Database.Player", "LastEditedBy")
+                        .WithMany("AdminNotesLastEdited")
+                        .HasForeignKey("LastEditedById")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .HasConstraintName("FK_admin_notes_player_last_edited_by_id");
+
+                    b.HasOne("Content.Server.Database.Player", "Player")
+                        .WithMany("AdminNotesReceived")
+                        .HasForeignKey("PlayerUserId")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .HasConstraintName("FK_admin_notes_player_player_user_id");
+
+                    b.HasOne("Content.Server.Database.Round", "Round")
+                        .WithMany()
+                        .HasForeignKey("RoundId")
+                        .HasConstraintName("FK_admin_notes_round_round_id");
+
+                    b.Navigation("CreatedBy");
+
+                    b.Navigation("DeletedBy");
+
+                    b.Navigation("LastEditedBy");
+
+                    b.Navigation("Player");
+
+                    b.Navigation("Round");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminRankFlag", b =>
+                {
+                    b.HasOne("Content.Server.Database.AdminRank", "Rank")
+                        .WithMany("Flags")
+                        .HasForeignKey("AdminRankId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_admin_rank_flag_admin_rank_admin_rank_id");
+
+                    b.Navigation("Rank");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminWatchlist", b =>
+                {
+                    b.HasOne("Content.Server.Database.Player", "CreatedBy")
+                        .WithMany("AdminWatchlistsCreated")
+                        .HasForeignKey("CreatedById")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .HasConstraintName("FK_admin_watchlists_player_created_by_id");
+
+                    b.HasOne("Content.Server.Database.Player", "DeletedBy")
+                        .WithMany("AdminWatchlistsDeleted")
+                        .HasForeignKey("DeletedById")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .HasConstraintName("FK_admin_watchlists_player_deleted_by_id");
+
+                    b.HasOne("Content.Server.Database.Player", "LastEditedBy")
+                        .WithMany("AdminWatchlistsLastEdited")
+                        .HasForeignKey("LastEditedById")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .HasConstraintName("FK_admin_watchlists_player_last_edited_by_id");
+
+                    b.HasOne("Content.Server.Database.Player", "Player")
+                        .WithMany("AdminWatchlistsReceived")
+                        .HasForeignKey("PlayerUserId")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .HasConstraintName("FK_admin_watchlists_player_player_user_id");
+
+                    b.HasOne("Content.Server.Database.Round", "Round")
+                        .WithMany()
+                        .HasForeignKey("RoundId")
+                        .HasConstraintName("FK_admin_watchlists_round_round_id");
+
+                    b.Navigation("CreatedBy");
+
+                    b.Navigation("DeletedBy");
+
+                    b.Navigation("LastEditedBy");
+
+                    b.Navigation("Player");
+
+                    b.Navigation("Round");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Antag", b =>
+                {
+                    b.HasOne("Content.Server.Database.Profile", "Profile")
+                        .WithMany("Antags")
+                        .HasForeignKey("ProfileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_antag_profile_profile_id");
+
+                    b.Navigation("Profile");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.CDModel+CDProfile", b =>
+                {
+                    b.HasOne("Content.Server.Database.Profile", "Profile")
+                        .WithOne("CDProfile")
+                        .HasForeignKey("Content.Server.Database.CDModel+CDProfile", "ProfileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_cdprofile_profile_profile_id");
+
+                    b.Navigation("Profile");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.CDModel+CharacterRecordEntry", b =>
+                {
+                    b.HasOne("Content.Server.Database.CDModel+CDProfile", "CDProfile")
+                        .WithMany("CharacterRecordEntries")
+                        .HasForeignKey("CDProfileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_cd_character_record_entries_cdprofile_cdprofile_id");
+
+                    b.Navigation("CDProfile");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ConnectionLog", b =>
+                {
+                    b.HasOne("Content.Server.Database.Server", "Server")
+                        .WithMany("ConnectionLogs")
+                        .HasForeignKey("ServerId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .IsRequired()
+                        .HasConstraintName("FK_connection_log_server_server_id");
+
+                    b.OwnsOne("Content.Server.Database.TypedHwid", "HWId", b1 =>
+                        {
+                            b1.Property<int>("ConnectionLogId")
+                                .HasColumnType("INTEGER")
+                                .HasColumnName("connection_log_id");
+
+                            b1.Property<byte[]>("Hwid")
+                                .IsRequired()
+                                .HasColumnType("BLOB")
+                                .HasColumnName("hwid");
+
+                            b1.Property<int>("Type")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("INTEGER")
+                                .HasDefaultValue(0)
+                                .HasColumnName("hwid_type");
+
+                            b1.HasKey("ConnectionLogId");
+
+                            b1.ToTable("connection_log");
+
+                            b1.WithOwner()
+                                .HasForeignKey("ConnectionLogId")
+                                .HasConstraintName("FK_connection_log_connection_log_connection_log_id");
+                        });
+
+                    b.Navigation("HWId");
+
+                    b.Navigation("Server");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Job", b =>
+                {
+                    b.HasOne("Content.Server.Database.Profile", "Profile")
+                        .WithMany("Jobs")
+                        .HasForeignKey("ProfileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_job_profile_profile_id");
+
+                    b.Navigation("Profile");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Player", b =>
+                {
+                    b.OwnsOne("Content.Server.Database.TypedHwid", "LastSeenHWId", b1 =>
+                        {
+                            b1.Property<int>("PlayerId")
+                                .HasColumnType("INTEGER")
+                                .HasColumnName("player_id");
+
+                            b1.Property<byte[]>("Hwid")
+                                .IsRequired()
+                                .HasColumnType("BLOB")
+                                .HasColumnName("last_seen_hwid");
+
+                            b1.Property<int>("Type")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("INTEGER")
+                                .HasDefaultValue(0)
+                                .HasColumnName("last_seen_hwid_type");
+
+                            b1.HasKey("PlayerId");
+
+                            b1.ToTable("player");
+
+                            b1.WithOwner()
+                                .HasForeignKey("PlayerId")
+                                .HasConstraintName("FK_player_player_player_id");
+                        });
+
+                    b.Navigation("LastSeenHWId");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Profile", b =>
+                {
+                    b.HasOne("Content.Server.Database.Preference", "Preference")
+                        .WithMany("Profiles")
+                        .HasForeignKey("PreferenceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_profile_preference_preference_id");
+
+                    b.Navigation("Preference");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ProfileLoadout", b =>
+                {
+                    b.HasOne("Content.Server.Database.ProfileLoadoutGroup", "ProfileLoadoutGroup")
+                        .WithMany("Loadouts")
+                        .HasForeignKey("ProfileLoadoutGroupId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_profile_loadout_profile_loadout_group_profile_loadout_group_id");
+
+                    b.Navigation("ProfileLoadoutGroup");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ProfileLoadoutGroup", b =>
+                {
+                    b.HasOne("Content.Server.Database.ProfileRoleLoadout", "ProfileRoleLoadout")
+                        .WithMany("Groups")
+                        .HasForeignKey("ProfileRoleLoadoutId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_profile_loadout_group_profile_role_loadout_profile_role_loadout_id");
+
+                    b.Navigation("ProfileRoleLoadout");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ProfileRoleLoadout", b =>
+                {
+                    b.HasOne("Content.Server.Database.Profile", "Profile")
+                        .WithMany("Loadouts")
+                        .HasForeignKey("ProfileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_profile_role_loadout_profile_profile_id");
+
+                    b.Navigation("Profile");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.RoleWhitelist", b =>
+                {
+                    b.HasOne("Content.Server.Database.Player", "Player")
+                        .WithMany("JobWhitelists")
+                        .HasForeignKey("PlayerUserId")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_role_whitelists_player_player_user_id");
+
+                    b.Navigation("Player");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Round", b =>
+                {
+                    b.HasOne("Content.Server.Database.Server", "Server")
+                        .WithMany("Rounds")
+                        .HasForeignKey("ServerId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_round_server_server_id");
+
+                    b.Navigation("Server");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerBan", b =>
+                {
+                    b.HasOne("Content.Server.Database.Player", "CreatedBy")
+                        .WithMany("AdminServerBansCreated")
+                        .HasForeignKey("BanningAdmin")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .HasConstraintName("FK_server_ban_player_banning_admin");
+
+                    b.HasOne("Content.Server.Database.Player", "LastEditedBy")
+                        .WithMany("AdminServerBansLastEdited")
+                        .HasForeignKey("LastEditedById")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .HasConstraintName("FK_server_ban_player_last_edited_by_id");
+
+                    b.HasOne("Content.Server.Database.Round", "Round")
+                        .WithMany()
+                        .HasForeignKey("RoundId")
+                        .HasConstraintName("FK_server_ban_round_round_id");
+
+                    b.OwnsOne("Content.Server.Database.TypedHwid", "HWId", b1 =>
+                        {
+                            b1.Property<int>("ServerBanId")
+                                .HasColumnType("INTEGER")
+                                .HasColumnName("server_ban_id");
+
+                            b1.Property<byte[]>("Hwid")
+                                .IsRequired()
+                                .HasColumnType("BLOB")
+                                .HasColumnName("hwid");
+
+                            b1.Property<int>("Type")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("INTEGER")
+                                .HasDefaultValue(0)
+                                .HasColumnName("hwid_type");
+
+                            b1.HasKey("ServerBanId");
+
+                            b1.ToTable("server_ban");
+
+                            b1.WithOwner()
+                                .HasForeignKey("ServerBanId")
+                                .HasConstraintName("FK_server_ban_server_ban_server_ban_id");
+                        });
+
+                    b.Navigation("CreatedBy");
+
+                    b.Navigation("HWId");
+
+                    b.Navigation("LastEditedBy");
+
+                    b.Navigation("Round");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerBanHit", b =>
+                {
+                    b.HasOne("Content.Server.Database.ServerBan", "Ban")
+                        .WithMany("BanHits")
+                        .HasForeignKey("BanId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_server_ban_hit_server_ban_ban_id");
+
+                    b.HasOne("Content.Server.Database.ConnectionLog", "Connection")
+                        .WithMany("BanHits")
+                        .HasForeignKey("ConnectionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_server_ban_hit_connection_log_connection_id");
+
+                    b.Navigation("Ban");
+
+                    b.Navigation("Connection");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerRoleBan", b =>
+                {
+                    b.HasOne("Content.Server.Database.Player", "CreatedBy")
+                        .WithMany("AdminServerRoleBansCreated")
+                        .HasForeignKey("BanningAdmin")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .HasConstraintName("FK_server_role_ban_player_banning_admin");
+
+                    b.HasOne("Content.Server.Database.Player", "LastEditedBy")
+                        .WithMany("AdminServerRoleBansLastEdited")
+                        .HasForeignKey("LastEditedById")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .HasConstraintName("FK_server_role_ban_player_last_edited_by_id");
+
+                    b.HasOne("Content.Server.Database.Round", "Round")
+                        .WithMany()
+                        .HasForeignKey("RoundId")
+                        .HasConstraintName("FK_server_role_ban_round_round_id");
+
+                    b.OwnsOne("Content.Server.Database.TypedHwid", "HWId", b1 =>
+                        {
+                            b1.Property<int>("ServerRoleBanId")
+                                .HasColumnType("INTEGER")
+                                .HasColumnName("server_role_ban_id");
+
+                            b1.Property<byte[]>("Hwid")
+                                .IsRequired()
+                                .HasColumnType("BLOB")
+                                .HasColumnName("hwid");
+
+                            b1.Property<int>("Type")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("INTEGER")
+                                .HasDefaultValue(0)
+                                .HasColumnName("hwid_type");
+
+                            b1.HasKey("ServerRoleBanId");
+
+                            b1.ToTable("server_role_ban");
+
+                            b1.WithOwner()
+                                .HasForeignKey("ServerRoleBanId")
+                                .HasConstraintName("FK_server_role_ban_server_role_ban_server_role_ban_id");
+                        });
+
+                    b.Navigation("CreatedBy");
+
+                    b.Navigation("HWId");
+
+                    b.Navigation("LastEditedBy");
+
+                    b.Navigation("Round");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerRoleUnban", b =>
+                {
+                    b.HasOne("Content.Server.Database.ServerRoleBan", "Ban")
+                        .WithOne("Unban")
+                        .HasForeignKey("Content.Server.Database.ServerRoleUnban", "BanId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_server_role_unban_server_role_ban_ban_id");
+
+                    b.Navigation("Ban");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerUnban", b =>
+                {
+                    b.HasOne("Content.Server.Database.ServerBan", "Ban")
+                        .WithOne("Unban")
+                        .HasForeignKey("Content.Server.Database.ServerUnban", "BanId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_server_unban_server_ban_ban_id");
+
+                    b.Navigation("Ban");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Trait", b =>
+                {
+                    b.HasOne("Content.Server.Database.Profile", "Profile")
+                        .WithMany("Traits")
+                        .HasForeignKey("ProfileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_trait_profile_profile_id");
+
+                    b.Navigation("Profile");
+                });
+
+            modelBuilder.Entity("PlayerRound", b =>
+                {
+                    b.HasOne("Content.Server.Database.Player", null)
+                        .WithMany()
+                        .HasForeignKey("PlayersId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_player_round_player_players_id");
+
+                    b.HasOne("Content.Server.Database.Round", null)
+                        .WithMany()
+                        .HasForeignKey("RoundsId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_player_round_round_rounds_id");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Admin", b =>
+                {
+                    b.Navigation("Flags");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminLog", b =>
+                {
+                    b.Navigation("Players");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminRank", b =>
+                {
+                    b.Navigation("Admins");
+
+                    b.Navigation("Flags");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.CDModel+CDProfile", b =>
+                {
+                    b.Navigation("CharacterRecordEntries");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ConnectionLog", b =>
+                {
+                    b.Navigation("BanHits");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Player", b =>
+                {
+                    b.Navigation("AdminLogs");
+
+                    b.Navigation("AdminMessagesCreated");
+
+                    b.Navigation("AdminMessagesDeleted");
+
+                    b.Navigation("AdminMessagesLastEdited");
+
+                    b.Navigation("AdminMessagesReceived");
+
+                    b.Navigation("AdminNotesCreated");
+
+                    b.Navigation("AdminNotesDeleted");
+
+                    b.Navigation("AdminNotesLastEdited");
+
+                    b.Navigation("AdminNotesReceived");
+
+                    b.Navigation("AdminServerBansCreated");
+
+                    b.Navigation("AdminServerBansLastEdited");
+
+                    b.Navigation("AdminServerRoleBansCreated");
+
+                    b.Navigation("AdminServerRoleBansLastEdited");
+
+                    b.Navigation("AdminWatchlistsCreated");
+
+                    b.Navigation("AdminWatchlistsDeleted");
+
+                    b.Navigation("AdminWatchlistsLastEdited");
+
+                    b.Navigation("AdminWatchlistsReceived");
+
+                    b.Navigation("JobWhitelists");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Preference", b =>
+                {
+                    b.Navigation("Profiles");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Profile", b =>
+                {
+                    b.Navigation("Antags");
+
+                    b.Navigation("CDProfile");
+
+                    b.Navigation("Jobs");
+
+                    b.Navigation("Loadouts");
+
+                    b.Navigation("Traits");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ProfileLoadoutGroup", b =>
+                {
+                    b.Navigation("Loadouts");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ProfileRoleLoadout", b =>
+                {
+                    b.Navigation("Groups");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Round", b =>
+                {
+                    b.Navigation("AdminLogs");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Server", b =>
+                {
+                    b.Navigation("ConnectionLogs");
+
+                    b.Navigation("Rounds");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerBan", b =>
+                {
+                    b.Navigation("BanHits");
+
+                    b.Navigation("Unban");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerRoleBan", b =>
+                {
+                    b.Navigation("Unban");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/Content.Server.Database/Migrations/Sqlite/20250303043130_CosmaticDriftCharacterRecords.cs b/Content.Server.Database/Migrations/Sqlite/20250303043130_CosmaticDriftCharacterRecords.cs
new file mode 100644
index 0000000000..ce39b13e30
--- /dev/null
+++ b/Content.Server.Database/Migrations/Sqlite/20250303043130_CosmaticDriftCharacterRecords.cs
@@ -0,0 +1,84 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Content.Server.Database.Migrations.Sqlite
+{
+    /// <inheritdoc />
+    public partial class CosmaticDriftCharacterRecords : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "cdprofile",
+                columns: table => new
+                {
+                    cdprofile_id = table.Column<int>(type: "INTEGER", nullable: false)
+                        .Annotation("Sqlite:Autoincrement", true),
+                    profile_id = table.Column<int>(type: "INTEGER", nullable: false),
+                    height = table.Column<float>(type: "REAL", nullable: false),
+                    character_records = table.Column<byte[]>(type: "jsonb", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_cdprofile", x => x.cdprofile_id);
+                    table.ForeignKey(
+                        name: "FK_cdprofile_profile_profile_id",
+                        column: x => x.profile_id,
+                        principalTable: "profile",
+                        principalColumn: "profile_id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "cd_character_record_entries",
+                columns: table => new
+                {
+                    cd_character_record_entries_id = table.Column<int>(type: "INTEGER", nullable: false)
+                        .Annotation("Sqlite:Autoincrement", true),
+                    title = table.Column<string>(type: "TEXT", nullable: false),
+                    involved = table.Column<string>(type: "TEXT", nullable: false),
+                    description = table.Column<string>(type: "TEXT", nullable: false),
+                    type = table.Column<byte>(type: "INTEGER", nullable: false),
+                    cdprofile_id = table.Column<int>(type: "INTEGER", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_cd_character_record_entries", x => x.cd_character_record_entries_id);
+                    table.ForeignKey(
+                        name: "FK_cd_character_record_entries_cdprofile_cdprofile_id",
+                        column: x => x.cdprofile_id,
+                        principalTable: "cdprofile",
+                        principalColumn: "cdprofile_id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_cd_character_record_entries_cd_character_record_entries_id",
+                table: "cd_character_record_entries",
+                column: "cd_character_record_entries_id");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_cd_character_record_entries_cdprofile_id",
+                table: "cd_character_record_entries",
+                column: "cdprofile_id");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_cdprofile_profile_id",
+                table: "cdprofile",
+                column: "profile_id",
+                unique: true);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "cd_character_record_entries");
+
+            migrationBuilder.DropTable(
+                name: "cdprofile");
+        }
+    }
+}
diff --git a/Content.Server.Database/Migrations/Sqlite/SqliteServerDbContextModelSnapshot.cs b/Content.Server.Database/Migrations/Sqlite/SqliteServerDbContextModelSnapshot.cs
index 6c463c5bcb..d9eab738df 100644
--- a/Content.Server.Database/Migrations/Sqlite/SqliteServerDbContextModelSnapshot.cs
+++ b/Content.Server.Database/Migrations/Sqlite/SqliteServerDbContextModelSnapshot.cs
@@ -547,6 +547,76 @@ namespace Content.Server.Database.Migrations.Sqlite
                     b.ToTable("blacklist", (string)null);
                 });
 
+            modelBuilder.Entity("Content.Server.Database.CDModel+CDProfile", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("cdprofile_id");
+
+                    b.Property<byte[]>("CharacterRecords")
+                        .HasColumnType("jsonb")
+                        .HasColumnName("character_records");
+
+                    b.Property<float>("Height")
+                        .HasColumnType("REAL")
+                        .HasColumnName("height");
+
+                    b.Property<int>("ProfileId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("profile_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_cdprofile");
+
+                    b.HasIndex("ProfileId")
+                        .IsUnique();
+
+                    b.ToTable("cdprofile", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.CDModel+CharacterRecordEntry", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("cd_character_record_entries_id");
+
+                    b.Property<int>("CDProfileId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("cdprofile_id");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("description");
+
+                    b.Property<string>("Involved")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("involved");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("title");
+
+                    b.Property<byte>("Type")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("type");
+
+                    b.HasKey("Id")
+                        .HasName("PK_cd_character_record_entries");
+
+                    b.HasIndex("CDProfileId")
+                        .HasDatabaseName("IX_cd_character_record_entries_cdprofile_id");
+
+                    b.HasIndex("Id")
+                        .HasDatabaseName("IX_cd_character_record_entries_cd_character_record_entries_id");
+
+                    b.ToTable("cd_character_record_entries", (string)null);
+                });
+
             modelBuilder.Entity("Content.Server.Database.ConnectionLog", b =>
                 {
                     b.Property<int>("Id")
@@ -1580,6 +1650,30 @@ namespace Content.Server.Database.Migrations.Sqlite
                     b.Navigation("Profile");
                 });
 
+            modelBuilder.Entity("Content.Server.Database.CDModel+CDProfile", b =>
+                {
+                    b.HasOne("Content.Server.Database.Profile", "Profile")
+                        .WithOne("CDProfile")
+                        .HasForeignKey("Content.Server.Database.CDModel+CDProfile", "ProfileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_cdprofile_profile_profile_id");
+
+                    b.Navigation("Profile");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.CDModel+CharacterRecordEntry", b =>
+                {
+                    b.HasOne("Content.Server.Database.CDModel+CDProfile", "CDProfile")
+                        .WithMany("CharacterRecordEntries")
+                        .HasForeignKey("CDProfileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_cd_character_record_entries_cdprofile_cdprofile_id");
+
+                    b.Navigation("CDProfile");
+                });
+
             modelBuilder.Entity("Content.Server.Database.ConnectionLog", b =>
                 {
                     b.HasOne("Content.Server.Database.Server", "Server")
@@ -1939,6 +2033,11 @@ namespace Content.Server.Database.Migrations.Sqlite
                     b.Navigation("Flags");
                 });
 
+            modelBuilder.Entity("Content.Server.Database.CDModel+CDProfile", b =>
+                {
+                    b.Navigation("CharacterRecordEntries");
+                });
+
             modelBuilder.Entity("Content.Server.Database.ConnectionLog", b =>
                 {
                     b.Navigation("BanHits");
@@ -1992,6 +2091,8 @@ namespace Content.Server.Database.Migrations.Sqlite
                 {
                     b.Navigation("Antags");
 
+                    b.Navigation("CDProfile");
+
                     b.Navigation("Jobs");
 
                     b.Navigation("Loadouts");
diff --git a/Content.Server.Database/Model.cs b/Content.Server.Database/Model.cs
index 88d0a582b2..34abc82446 100644
--- a/Content.Server.Database/Model.cs
+++ b/Content.Server.Database/Model.cs
@@ -57,6 +57,20 @@ namespace Content.Server.Database
                 .HasIndex(p => new {p.Slot, PrefsId = p.PreferenceId})
                 .IsUnique();
 
+            // Begin CD - CD Character Data
+            modelBuilder.Entity<CDModel.CDProfile>()
+                .HasOne(p => p.Profile)
+                .WithOne(p => p.CDProfile)
+                .HasForeignKey<CDModel.CDProfile>(p => p.ProfileId)
+                .IsRequired();
+
+            modelBuilder.Entity<CDModel.CharacterRecordEntry>()
+                .HasOne(e => e.CDProfile)
+                .WithMany(e => e.CharacterRecordEntries)
+                .HasForeignKey(e => e.CDProfileId)
+                .IsRequired();
+            // End CD - CD Character Data
+
             modelBuilder.Entity<Antag>()
                 .HasIndex(p => new {HumanoidProfileId = p.ProfileId, p.AntagName})
                 .IsUnique();
@@ -423,6 +437,8 @@ namespace Content.Server.Database
 
         public int PreferenceId { get; set; }
         public Preference Preference { get; set; } = null!;
+
+        public CDModel.CDProfile? CDProfile { get; set; } // CD - Character Records
     }
 
     public class Job
diff --git a/Content.Server.Database/ModelSqlite.cs b/Content.Server.Database/ModelSqlite.cs
index 1ce9465847..2c3020ea43 100644
--- a/Content.Server.Database/ModelSqlite.cs
+++ b/Content.Server.Database/ModelSqlite.cs
@@ -82,6 +82,12 @@ namespace Content.Server.Database
                 .Property(log => log.Markings)
                 .HasConversion(jsonByteArrayConverter);
 
+            // Begin CD - Character Records
+            modelBuilder.Entity<CDModel.CDProfile>()
+                .Property(log => log.CharacterRecords)
+                .HasConversion(jsonByteArrayConverter);
+            // End CD - Character Records
+
             // EF core can make this automatically unique on sqlite but not psql.
             modelBuilder.Entity<IPIntelCache>()
                 .HasIndex(p => p.Address)
diff --git a/Content.Server/Database/ServerDbBase.cs b/Content.Server/Database/ServerDbBase.cs
index 030c2b4bb5..1b60db6752 100644
--- a/Content.Server/Database/ServerDbBase.cs
+++ b/Content.Server/Database/ServerDbBase.cs
@@ -21,6 +21,8 @@ using Robust.Shared.Enums;
 using Robust.Shared.Network;
 using Robust.Shared.Prototypes;
 using Robust.Shared.Utility;
+using Content.Server._CD.Records; // CD - Character Records
+using Content.Shared._CD.Records; // CD - Character Records
 
 namespace Content.Server.Database
 {
@@ -48,6 +50,11 @@ namespace Content.Server.Database
                 .Include(p => p.Profiles).ThenInclude(h => h.Jobs)
                 .Include(p => p.Profiles).ThenInclude(h => h.Antags)
                 .Include(p => p.Profiles).ThenInclude(h => h.Traits)
+                // Begin CD - Character Records
+                .Include(p => p.Profiles)
+                    .ThenInclude(h => h.CDProfile)
+                    .ThenInclude(cd => cd != null ? cd.CharacterRecordEntries : null)
+                // End CD - Character Records
                 .Include(p => p.Profiles)
                     .ThenInclude(h => h.Loadouts)
                     .ThenInclude(l => l.Groups)
@@ -95,6 +102,8 @@ namespace Content.Server.Database
             }
 
             var oldProfile = db.DbContext.Profile
+                .Include(p => p.CDProfile) // CD - Character Records
+                    .ThenInclude(cd => cd != null ? cd.CharacterRecordEntries : null)
                 .Include(p => p.Preference)
                 .Where(p => p.Preference.UserId == userId.UserId)
                 .Include(p => p.Jobs)
@@ -216,6 +225,11 @@ namespace Content.Server.Database
                 }
             }
 
+            // Begin CD - Chracter Records
+            var cdRecords = profile.CDProfile?.CharacterRecords != null
+                ? RecordsSerialization.Deserialize(profile.CDProfile.CharacterRecords, profile.CDProfile.CharacterRecordEntries)
+                : PlayerProvidedCharacterRecords.DefaultRecords();
+            // End CD - Character Records
             var loadouts = new Dictionary<string, RoleLoadout>();
 
             foreach (var role in profile.Loadouts)
@@ -262,7 +276,9 @@ namespace Content.Server.Database
                 (PreferenceUnavailableMode) profile.PreferenceUnavailable,
                 antags.ToHashSet(),
                 traits.ToHashSet(),
-                loadouts
+                loadouts,
+                profile.CDProfile?.Height ?? 1.0f, // CD - Character Records
+                cdRecords // CD - Character Records
             );
         }
 
@@ -313,6 +329,18 @@ namespace Content.Server.Database
                         .Select(t => new Trait {TraitName = t})
             );
 
+            // Begin CD - Character Records
+            profile.CDProfile ??= new CDModel.CDProfile();
+            profile.CDProfile.Height = humanoid.Height;
+            // There are JsonIgnore annotations to ensure that entries are not stored as JSON.
+            profile.CDProfile.CharacterRecords = JsonSerializer.SerializeToDocument(humanoid.CDCharacterRecords ?? PlayerProvidedCharacterRecords.DefaultRecords());
+            if (humanoid.CDCharacterRecords != null)
+            {
+                profile.CDProfile.CharacterRecordEntries.Clear();
+                profile.CDProfile.CharacterRecordEntries.AddRange(RecordsSerialization.GetEntries(humanoid.CDCharacterRecords));
+            }
+            // End CD - Character Records
+
             profile.Loadouts.Clear();
 
             foreach (var (role, loadouts) in humanoid.Loadouts)
diff --git a/Content.Server/_CD/Records/CharacterRecordKeyStorageComponent.cs b/Content.Server/_CD/Records/CharacterRecordKeyStorageComponent.cs
new file mode 100644
index 0000000000..29e56e386d
--- /dev/null
+++ b/Content.Server/_CD/Records/CharacterRecordKeyStorageComponent.cs
@@ -0,0 +1,17 @@
+namespace Content.Server._CD.Records;
+
+/// <summary>
+/// Stores the key to the entities character records.
+/// </summary>
+[RegisterComponent]
+[Access(typeof(CharacterRecordsSystem))]
+public sealed partial class CharacterRecordKeyStorageComponent : Component
+{
+    [ViewVariables(VVAccess.ReadOnly)]
+    public CharacterRecordKey Key;
+
+    public CharacterRecordKeyStorageComponent(CharacterRecordKey key)
+    {
+        Key = key;
+    }
+}
diff --git a/Content.Server/_CD/Records/CharacterRecordsComponent.cs b/Content.Server/_CD/Records/CharacterRecordsComponent.cs
new file mode 100644
index 0000000000..9ba6dd5529
--- /dev/null
+++ b/Content.Server/_CD/Records/CharacterRecordsComponent.cs
@@ -0,0 +1,31 @@
+using Content.Shared._CD.Records;
+
+namespace Content.Server._CD.Records;
+
+/// <summary>
+/// The component on the station that stores records after the round starts.
+/// </summary>
+[RegisterComponent]
+[Access(typeof(CharacterRecordsSystem))]
+public sealed partial class CharacterRecordsComponent : Component
+{
+    [ViewVariables(VVAccess.ReadOnly)]
+    public Dictionary<uint, FullCharacterRecords> Records = new();
+
+    [ViewVariables(VVAccess.ReadOnly)]
+    private uint _nextKey = 1;
+
+    /// <summary>
+    /// Creates a key has never been used previously
+    /// </summary>
+    public uint CreateNewKey()
+    {
+        return _nextKey++;
+    }
+}
+
+public sealed record CharacterRecordKey
+{
+    public EntityUid Station { get; init; }
+    public uint Index { get; init; }
+}
diff --git a/Content.Server/_CD/Records/CharacterRecordsSystem.cs b/Content.Server/_CD/Records/CharacterRecordsSystem.cs
new file mode 100644
index 0000000000..1737c4246c
--- /dev/null
+++ b/Content.Server/_CD/Records/CharacterRecordsSystem.cs
@@ -0,0 +1,194 @@
+using Content.Server.Forensics;
+using Content.Server.GameTicking;
+using Content.Server.StationRecords.Systems;
+using Content.Server.StationRecords;
+using Content.Shared.Inventory;
+using Content.Shared.PDA;
+using Content.Shared.Roles;
+using Content.Shared.StationRecords;
+using Content.Shared._CD.Records;
+using Content.Shared.Forensics.Components;
+using Content.Shared.GameTicking;
+using Robust.Shared.Prototypes;
+
+namespace Content.Server._CD.Records;
+
+public sealed class CharacterRecordsSystem : EntitySystem
+{
+    [Dependency] private readonly IPrototypeManager _prototype = default!;
+    [Dependency] private readonly InventorySystem _inventory = default!;
+    [Dependency] private readonly StationRecordsSystem _records = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<PlayerSpawnCompleteEvent>(OnPlayerSpawn, after: [typeof(StationRecordsSystem)]);
+    }
+
+    private void OnPlayerSpawn(PlayerSpawnCompleteEvent args)
+    {
+        if (!HasComp<StationRecordsComponent>(args.Station))
+        {
+            Log.Error("Tried to add CharacterRecords on a station without StationRecords");
+            return;
+        }
+        if (!HasComp<CharacterRecordsComponent>(args.Station))
+            AddComp<CharacterRecordsComponent>(args.Station);
+
+        if (string.IsNullOrEmpty(args.JobId))
+        {
+            Log.Error($"Null JobId in CharacterRecordsSystem::OnPlayerSpawn for character {args.Profile.Name} played by {args.Player.Name}");
+            return;
+        }
+
+        if (HasComp<SkipLoadingCharacterRecordsComponent>(args.Mob))
+            return;
+
+        var profile = args.Profile;
+        if (profile.CDCharacterRecords == null)
+        {
+            Log.Error($"Null records in CharacterRecordsSystem::OnPlayerSpawn for character {args.Profile.Name} played by {args.Player.Name}.");
+            return;
+        }
+
+        var player = args.Mob;
+
+        if (!_prototype.TryIndex(args.JobId, out JobPrototype? jobPrototype))
+        {
+            throw new ArgumentException($"Invalid job prototype ID: {args.JobId}");
+        }
+
+        TryComp<FingerprintComponent>(player, out var fingerprintComponent);
+        TryComp<DnaComponent>(player, out var dnaComponent);
+
+        var jobTitle = jobPrototype.LocalizedName;
+        var stationRecordsKey = FindStationRecordsKey(player);
+
+        // Grab the title from the station records if they exist to support our job title system
+        if (stationRecordsKey != null && _records.TryGetRecord<GeneralStationRecord>(stationRecordsKey.Value, out var stationRecords))
+        {
+            jobTitle = stationRecords.JobTitle;
+        }
+
+        var records = new FullCharacterRecords(
+            pRecords: new PlayerProvidedCharacterRecords(profile.CDCharacterRecords),
+            stationRecordsKey: stationRecordsKey?.Id,
+            name: profile.Name,
+            age: profile.Age,
+            species: profile.Species,
+            jobTitle: jobTitle,
+            jobIcon: jobPrototype.Icon,
+            gender: profile.Gender,
+            sex: profile.Sex,
+            fingerprint: fingerprintComponent?.Fingerprint,
+            dna: dnaComponent?.DNA,
+            owner: player);
+        AddRecord(args.Station, args.Mob, records);
+    }
+
+    private StationRecordKey? FindStationRecordsKey(EntityUid uid)
+    {
+        if (!_inventory.TryGetSlotEntity(uid, "id", out var idUid))
+            return null;
+
+        var keyStorageEntity = idUid;
+        if (TryComp<PdaComponent>(idUid, out var pda) && pda.ContainedId is {} id)
+        {
+            keyStorageEntity = id;
+        }
+
+        if (!TryComp<StationRecordKeyStorageComponent>(keyStorageEntity, out var storage))
+        {
+            return null;
+        }
+
+        return storage.Key;
+    }
+
+    private void AddRecord(EntityUid station, EntityUid player, FullCharacterRecords records, CharacterRecordsComponent? recordsDb = null)
+    {
+        if (!Resolve(station, ref recordsDb))
+            return;
+
+        var key = recordsDb.CreateNewKey();
+        recordsDb.Records.Add(key, records);
+        var playerKey = new CharacterRecordKey { Station = station, Index = key };
+        AddComp(player, new CharacterRecordKeyStorageComponent(playerKey));
+
+        RaiseLocalEvent(station, new CharacterRecordsModifiedEvent());
+    }
+
+    public void DelEntry(
+        EntityUid station,
+        EntityUid player,
+        CharacterRecordType ty,
+        int idx,
+        CharacterRecordsComponent? recordsDb = null,
+        CharacterRecordKeyStorageComponent? key = null)
+    {
+        if (!Resolve(station, ref recordsDb) || !Resolve(player, ref key))
+            return;
+
+        if (!recordsDb.Records.TryGetValue(key.Key.Index, out var value))
+            return;
+
+        var cr = value.PRecords;
+
+        switch (ty)
+        {
+            case CharacterRecordType.Employment:
+                cr.EmploymentEntries.RemoveAt(idx);
+                break;
+            case CharacterRecordType.Medical:
+                cr.MedicalEntries.RemoveAt(idx);
+                break;
+            case CharacterRecordType.Security:
+                cr.SecurityEntries.RemoveAt(idx);
+                break;
+        }
+
+        RaiseLocalEvent(station, new CharacterRecordsModifiedEvent());
+    }
+
+    public void ResetRecord(
+        EntityUid station,
+        EntityUid player,
+        CharacterRecordsComponent? recordsDb = null,
+        CharacterRecordKeyStorageComponent? key = null)
+    {
+        if (!Resolve(station, ref recordsDb) || !Resolve(player, ref key))
+            return;
+
+        if (!recordsDb.Records.TryGetValue(key.Key.Index, out var value))
+            return;
+
+        var records = PlayerProvidedCharacterRecords.DefaultRecords();
+        if (TryComp(player, out MetaDataComponent? meta))
+            value.Name = meta.EntityName;
+        value.PRecords = records;
+        RaiseLocalEvent(station, new CharacterRecordsModifiedEvent());
+    }
+
+    public void DeleteAllRecords(EntityUid player, CharacterRecordKeyStorageComponent? key = null)
+    {
+        if (!Resolve(player, ref key))
+            return;
+
+        var station = key.Key.Station;
+        CharacterRecordsComponent? records = null;
+        if (!Resolve(station, ref records))
+            return;
+
+        records.Records.Remove(key.Key.Index);
+    }
+
+    public IDictionary<uint, FullCharacterRecords> QueryRecords(EntityUid station, CharacterRecordsComponent? recordsDb = null)
+    {
+        return !Resolve(station, ref recordsDb)
+            ? new Dictionary<uint, FullCharacterRecords>()
+            : recordsDb.Records;
+    }
+}
+
+public sealed class CharacterRecordsModifiedEvent : EntityEventArgs;
diff --git a/Content.Server/_CD/Records/Commands/DelRecordEntryCommand.cs b/Content.Server/_CD/Records/Commands/DelRecordEntryCommand.cs
new file mode 100644
index 0000000000..448965703c
--- /dev/null
+++ b/Content.Server/_CD/Records/Commands/DelRecordEntryCommand.cs
@@ -0,0 +1,55 @@
+using Content.Server.Administration;
+using Content.Server.Station.Systems;
+using Content.Shared._CD.Records;
+using Content.Shared.Administration;
+using Robust.Shared.Console;
+
+namespace Content.Server._CD.Records.Commands;
+
+[AdminCommand(AdminFlags.Ban)]
+public sealed class DelRecordEntryCommand : IConsoleCommand
+{
+    [Dependency] private readonly IEntityManager _entManager = default!;
+
+    public string Command => "delrecordentry";
+
+    public string Description =>
+        "Resets the records of the given entity to the default values. This is not saved to the database and only lasts until the round is over";
+
+    public string Help => $"{Command} <entity> <recordType> <index>";
+    public void Execute(IConsoleShell shell, string argStr, string[] args)
+    {
+        if (args.Length < 3)
+        {
+            shell.WriteLine($"Not enough arguments.\n{Help}");
+            return;
+        }
+
+        if (!NetEntity.TryParse(args[0], out var uidNet) || !_entManager.TryGetEntity(uidNet, out var uid))
+        {
+            shell.WriteLine($"Invalid entity id.");
+            return;
+        }
+
+        if (!Enum.TryParse<CharacterRecordType>(args[1], out var ty))
+        {
+            shell.WriteLine($"Invalid entry type.");
+            return;
+        }
+
+        if (!int.TryParse(args[2], out var idx))
+        {
+            shell.WriteLine($"Invalid index.");
+            return;
+        }
+
+        var characterRecordsSystem = _entManager.System<CharacterRecordsSystem>();
+        var stationSystem = _entManager.System<StationSystem>();
+
+        foreach (var s in stationSystem.GetStations())
+        {
+            characterRecordsSystem.DelEntry(s, uid.Value, ty, idx);
+        }
+    }
+
+}
diff --git a/Content.Server/_CD/Records/Commands/PurgeCharacterRecordsCommand.cs b/Content.Server/_CD/Records/Commands/PurgeCharacterRecordsCommand.cs
new file mode 100644
index 0000000000..6358203ae6
--- /dev/null
+++ b/Content.Server/_CD/Records/Commands/PurgeCharacterRecordsCommand.cs
@@ -0,0 +1,42 @@
+using Content.Server.Administration;
+using Content.Server.Station.Systems;
+using Content.Shared.Administration;
+using Robust.Shared.Console;
+
+namespace Content.Server._CD.Records.Commands;
+
+[AdminCommand(AdminFlags.Ban)]
+public sealed class PurgeCharacterRecordsCommand : IConsoleCommand
+{
+    [Dependency] private readonly IEntityManager _entManager = default!;
+
+    public string Command => "purgecharacterrecords";
+
+    public string Description =>
+        "Resets the records of the given entity to the default values. This is not saved to the database and only lasts until the round is over";
+
+    public string Help => $"{Command} <entity>";
+    public void Execute(IConsoleShell shell, string argStr, string[] args)
+    {
+        if (args.Length < 1)
+        {
+            shell.WriteLine($"Not enough arguments.\n{Help}");
+            return;
+        }
+
+        if (!NetEntity.TryParse(args[0], out var uidNet) || !_entManager.TryGetEntity(uidNet, out var uid))
+        {
+            shell.WriteLine($"Invalid entity id.");
+            return;
+        }
+
+        var characterRecordsSystem = _entManager.System<CharacterRecordsSystem>();
+        var stationSystem = _entManager.System<StationSystem>();
+
+        foreach (var s in stationSystem.GetStations())
+        {
+            characterRecordsSystem.ResetRecord(s, uid.Value);
+        }
+    }
+
+}
diff --git a/Content.Server/_CD/Records/Consoles/CharacterRecordConsoleComponent.cs b/Content.Server/_CD/Records/Consoles/CharacterRecordConsoleComponent.cs
new file mode 100644
index 0000000000..94d68f5829
--- /dev/null
+++ b/Content.Server/_CD/Records/Consoles/CharacterRecordConsoleComponent.cs
@@ -0,0 +1,17 @@
+using Content.Shared._CD.Records;
+using Content.Shared.StationRecords;
+
+namespace Content.Server._CD.Records.Consoles;
+
+[RegisterComponent]
+public sealed partial class CharacterRecordConsoleComponent : Component
+{
+    [ViewVariables(VVAccess.ReadOnly)]
+    public uint? SelectedIndex { get; set; }
+
+    [ViewVariables(VVAccess.ReadOnly)]
+    public StationRecordsFilter? Filter;
+
+    [DataField(required: true), ViewVariables(VVAccess.ReadOnly)]
+    public RecordConsoleType ConsoleType;
+}
diff --git a/Content.Server/_CD/Records/Consoles/CharacterRecordConsoleSystem.cs b/Content.Server/_CD/Records/Consoles/CharacterRecordConsoleSystem.cs
new file mode 100644
index 0000000000..4f55d3d979
--- /dev/null
+++ b/Content.Server/_CD/Records/Consoles/CharacterRecordConsoleSystem.cs
@@ -0,0 +1,152 @@
+using Content.Server.Station.Systems;
+using Content.Server.StationRecords.Systems;
+using Content.Server.StationRecords;
+using Content.Shared.CriminalRecords;
+using Content.Shared.Security;
+using Content.Shared.StationRecords;
+using Content.Shared._CD.Records;
+using Robust.Server.GameObjects;
+
+namespace Content.Server._CD.Records.Consoles;
+
+public sealed class CharacterRecordConsoleSystem : EntitySystem
+{
+    [Dependency] private readonly CharacterRecordsSystem _characterRecords = default!;
+    [Dependency] private readonly IEntityManager _entity = default!;
+    [Dependency] private readonly StationRecordsSystem _records = default!;
+    [Dependency] private readonly StationSystem _station = default!;
+    [Dependency] private readonly UserInterfaceSystem _ui = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<CharacterRecordConsoleComponent, CharacterRecordsModifiedEvent>((uid, component, _) =>
+            UpdateUi(uid, component));
+
+        Subs.BuiEvents<CharacterRecordConsoleComponent>(CharacterRecordConsoleKey.Key,
+            subr =>
+            {
+                subr.Event<BoundUIOpenedEvent>((uid, component, _) => UpdateUi(uid, component));
+                subr.Event<CharacterRecordConsoleSelectMsg>(OnKeySelect);
+                subr.Event<CharacterRecordsConsoleFilterMsg>(OnFilterApplied);
+            });
+    }
+
+    private void OnFilterApplied(Entity<CharacterRecordConsoleComponent> ent, ref CharacterRecordsConsoleFilterMsg msg)
+    {
+        ent.Comp.Filter = msg.Filter;
+        UpdateUi(ent);
+    }
+
+    private void OnKeySelect(Entity<CharacterRecordConsoleComponent> ent, ref CharacterRecordConsoleSelectMsg msg)
+    {
+        ent.Comp.SelectedIndex = msg.CharacterRecordKey;
+        UpdateUi(ent);
+    }
+
+    private void UpdateUi(EntityUid entity, CharacterRecordConsoleComponent? console = null)
+    {
+        if (!Resolve(entity, ref console))
+            return;
+
+        var station = _station.GetOwningStation(entity);
+        if (!HasComp<StationRecordsComponent>(station) ||
+            !HasComp<CharacterRecordsComponent>(station))
+        {
+            SendState(entity, new CharacterRecordConsoleState { ConsoleType = console.ConsoleType });
+            return;
+        }
+
+        var characterRecords = _characterRecords.QueryRecords(station.Value);
+        // Get the name and station records key display from the list of records
+        var names = new Dictionary<uint, CharacterRecordConsoleState.CharacterInfo>();
+        foreach (var (i, r) in characterRecords)
+        {
+            var netEnt = _entity.GetNetEntity(r.Owner!.Value);
+            // Admins get additional info to make it easier to run commands
+            var nameJob = console.ConsoleType != RecordConsoleType.Admin
+                ? $"{r.Name} ({r.JobTitle})"
+                : $"{r.Name} ({netEnt}, {r.JobTitle}";
+
+            // Apply any filter the user has set
+            if (console.Filter != null)
+            {
+                if (IsSkippedRecord(console.Filter, r, nameJob))
+                    continue;
+            }
+
+            if (names.ContainsKey(i))
+            {
+                Log.Error(
+                    $"We somehow have duplicate character record keys, NetEntity: {i}, Entity: {entity}, Character Name: {r.Name}");
+            }
+
+            names[i] = new CharacterRecordConsoleState.CharacterInfo
+                { CharacterDisplayName = nameJob, StationRecordKey = r.StationRecordsKey };
+        }
+
+        var record =
+            console.SelectedIndex == null || !characterRecords.TryGetValue(console.SelectedIndex!.Value, out var value)
+                ? null
+                : value;
+        (SecurityStatus, string?)? securityStatus = null;
+
+        // If we need the character's security status, gather it from the criminal records
+        if ((console.ConsoleType == RecordConsoleType.Admin ||
+             console.ConsoleType == RecordConsoleType.Security)
+            && record?.StationRecordsKey != null)
+        {
+            var key = new StationRecordKey(record.StationRecordsKey.Value, station.Value);
+            if (_records.TryGetRecord<CriminalRecord>(key, out var entry))
+                securityStatus = (entry.Status, entry.Reason);
+        }
+
+        SendState(entity,
+            new CharacterRecordConsoleState
+            {
+                ConsoleType = console.ConsoleType,
+                CharacterList = names,
+                SelectedIndex = console.SelectedIndex,
+                SelectedRecord = record,
+                Filter = console.Filter,
+                SelectedSecurityStatus = securityStatus,
+            });
+    }
+
+    private void SendState(EntityUid entity, CharacterRecordConsoleState state)
+    {
+        _ui.SetUiState(entity, CharacterRecordConsoleKey.Key, state);
+    }
+
+    /// <summary>
+    /// Almost exactly the same as <see cref="StationRecordsSystem.IsSkipped"/>
+    /// </summary>
+    private static bool IsSkippedRecord(StationRecordsFilter filter,
+        FullCharacterRecords record,
+        string nameJob)
+    {
+        var isFilter = filter.Value.Length > 0;
+
+        if (!isFilter)
+            return false;
+
+        var filterLowerCaseValue = filter.Value.ToLower();
+
+        return filter.Type switch
+        {
+            StationRecordFilterType.Name =>
+                !nameJob.Contains(filterLowerCaseValue, StringComparison.CurrentCultureIgnoreCase),
+            StationRecordFilterType.Prints => record.Fingerprint != null
+                && IsFilterWithSomeCodeValue(record.Fingerprint, filterLowerCaseValue),
+            StationRecordFilterType.DNA => record.DNA != null
+                                                && IsFilterWithSomeCodeValue(record.DNA, filterLowerCaseValue),
+            _ => throw new ArgumentOutOfRangeException(nameof(filter), "Invalid Character Record filter type"),
+        };
+    }
+
+    private static bool IsFilterWithSomeCodeValue(string value, string filter)
+    {
+        return !value.StartsWith(filter, StringComparison.CurrentCultureIgnoreCase);
+    }
+}
diff --git a/Content.Server/_CD/Records/RecordsSerialization.cs b/Content.Server/_CD/Records/RecordsSerialization.cs
new file mode 100644
index 0000000000..a3b9754eaf
--- /dev/null
+++ b/Content.Server/_CD/Records/RecordsSerialization.cs
@@ -0,0 +1,93 @@
+using Content.Server.Database;
+using Content.Shared._CD.Records;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using System.Text.Json;
+
+namespace Content.Server._CD.Records;
+
+public static class RecordsSerialization
+{
+    private static int DeserializeInt(JsonElement e, string key, int def)
+    {
+        if (e.TryGetProperty(key, out var prop) && prop.TryGetInt32(out var v))
+        {
+            return v;
+        }
+
+        return def;
+    }
+
+    private static bool DeserializeBool(JsonElement e, string key, bool def)
+    {
+        if (!e.TryGetProperty(key, out var v))
+            return def;
+
+        return v.ValueKind switch
+        {
+            JsonValueKind.True => true,
+            JsonValueKind.False => false,
+            _ => def,
+        };
+    }
+
+    [return: NotNullIfNotNull(nameof(def))]
+    private static string? DeserializeString(JsonElement e, string key, string? def)
+    {
+        if (!e.TryGetProperty(key, out var v))
+            return def;
+
+        if (v.ValueKind == JsonValueKind.String)
+            return v.GetString() ?? def;
+
+        return def;
+    }
+
+    private static List<PlayerProvidedCharacterRecords.RecordEntry> DeserializeEntries(List<CDModel.CharacterRecordEntry> entries, CDModel.DbRecordEntryType ty)
+    {
+        return entries.Where(e => e.Type == ty)
+            .OrderBy(e => e.Id) // attempt at fixing the record order changing bug.
+            .Select(e => new PlayerProvidedCharacterRecords.RecordEntry(e.Title, e.Involved, e.Description))
+            .ToList();
+    }
+
+    /// <summary>
+    /// We need to manually deserialize CharacterRecords because the easy JSON deserializer does not
+    /// do exactly what we want. More specifically, we need to more robustly handle missing and extra fields
+    /// <br />
+    /// <br />
+    /// Missing fields are filled in with their default value, extra fields are simply ignored
+    /// </summary>
+    public static PlayerProvidedCharacterRecords Deserialize(JsonDocument json, List<CDModel.CharacterRecordEntry> entries)
+    {
+        var e = json.RootElement;
+        var def = PlayerProvidedCharacterRecords.DefaultRecords();
+        return new PlayerProvidedCharacterRecords(
+            height: DeserializeInt(e, nameof(def.Height), def.Height),
+            weight: DeserializeInt(e, nameof(def.Weight), def.Weight),
+            emergencyContactName: DeserializeString(e, nameof(def.EmergencyContactName), def.EmergencyContactName),
+            hasWorkAuthorization: DeserializeBool(e, nameof(def.HasWorkAuthorization), def.HasWorkAuthorization),
+            identifyingFeatures: DeserializeString(e, nameof(def.IdentifyingFeatures), def.IdentifyingFeatures),
+            allergies: DeserializeString(e, nameof(def.Allergies), def.Allergies),
+            drugAllergies: DeserializeString(e, nameof(def.DrugAllergies), def.DrugAllergies),
+            postmortemInstructions: DeserializeString(e, nameof(def.PostmortemInstructions), def.PostmortemInstructions),
+            medicalEntries: DeserializeEntries(entries, CDModel.DbRecordEntryType.Medical),
+            securityEntries: DeserializeEntries(entries, CDModel.DbRecordEntryType.Security),
+            employmentEntries: DeserializeEntries(entries, CDModel.DbRecordEntryType.Employment));
+    }
+
+    private static CDModel.CharacterRecordEntry ConvertEntry(PlayerProvidedCharacterRecords.RecordEntry entry, CDModel.DbRecordEntryType type)
+    {
+        entry.EnsureValid();
+        return new CDModel.CharacterRecordEntry()
+            { Title = entry.Title, Involved = entry.Involved, Description = entry.Description, Type = type };
+    }
+
+    public static List<CDModel.CharacterRecordEntry> GetEntries(PlayerProvidedCharacterRecords records)
+    {
+        return records.MedicalEntries.Select(medical => ConvertEntry(medical, CDModel.DbRecordEntryType.Medical))
+            .Concat(records.SecurityEntries.Select(security => ConvertEntry(security, CDModel.DbRecordEntryType.Security)))
+            .Concat(records.EmploymentEntries.Select(employment => ConvertEntry(employment, CDModel.DbRecordEntryType.Employment)))
+            .ToList();
+    }
+}
diff --git a/Content.Server/_CD/Records/SkipLoadingCharacterRecordsComponent.cs b/Content.Server/_CD/Records/SkipLoadingCharacterRecordsComponent.cs
new file mode 100644
index 0000000000..3c91cce1db
--- /dev/null
+++ b/Content.Server/_CD/Records/SkipLoadingCharacterRecordsComponent.cs
@@ -0,0 +1,4 @@
+namespace Content.Server._CD.Records;
+
+[RegisterComponent]
+public sealed partial class SkipLoadingCharacterRecordsComponent : Component;
diff --git a/Content.Shared/Humanoid/HumanoidAppearanceComponent.cs b/Content.Shared/Humanoid/HumanoidAppearanceComponent.cs
index a7e169d046..a79a9d9c10 100644
--- a/Content.Shared/Humanoid/HumanoidAppearanceComponent.cs
+++ b/Content.Shared/Humanoid/HumanoidAppearanceComponent.cs
@@ -85,6 +85,14 @@ public sealed partial class HumanoidAppearanceComponent : Component
     [ViewVariables(VVAccess.ReadOnly)]
     public Color? CachedFacialHairColor;
 
+    // CD - Character Records
+    /// <summary>
+    ///     The height of this humanoid.
+    /// </summary>
+    [DataField, AutoNetworkedField]
+    public float Height = 1f;
+    // CD - Character Records
+
     /// <summary>
     ///     Which layers of this humanoid that should be hidden on equipping a corresponding item..
     /// </summary>
diff --git a/Content.Shared/Humanoid/Prototypes/SpeciesPrototype.cs b/Content.Shared/Humanoid/Prototypes/SpeciesPrototype.cs
index 3dffb26f6d..1f7add4825 100644
--- a/Content.Shared/Humanoid/Prototypes/SpeciesPrototype.cs
+++ b/Content.Shared/Humanoid/Prototypes/SpeciesPrototype.cs
@@ -120,6 +120,52 @@ public sealed partial class SpeciesPrototype : IPrototype
     /// </summary>
     [DataField]
     public int MaxAge = 120;
+
+    // Begin DV - CD Character Records shouldn't nuke species heights
+    /// <summary>
+    /// The base height scale for this species
+    /// </summary>
+    [DataField("baseScale")]
+    public System.Numerics.Vector2 BaseScale = new(1f, 1f);
+    // End DV - CD Character Records shouldn't nuke species heights
+
+    // Begin CD - Character Records
+    /// <summary>
+    /// The minimum height for this species
+    /// </summary>
+    [DataField("minHeight")]
+    public float MinHeight = 0.85f; // DeltaV - less trolling with the heights
+
+    /// <summary>
+    /// The maximum height for this species
+    /// </summary>
+    [DataField("maxHeight")]
+    public float MaxHeight = 1.2f; // DeltaV - less trolling with the heights
+
+    /// <summary>
+    /// The default height for this species
+    /// </summary>
+    [DataField("defaultHeight")]
+    public float DefaultHeight = 1f;
+
+    /// <summary>
+    /// The default width for this species
+    /// </summary>
+    [DataField("defaultWidth")]
+    public float DefaultWidth = 1f;
+
+    /// <summary>
+    /// Whether to scale horizontally or not
+    /// </summary>
+    [DataField("scaleWidth")]
+    public bool ScaleWidth = true;
+
+    /// <summary>
+    /// Whether to scale vertically or not
+    /// </summary>
+    [DataField("scaleHeight")]
+    public bool ScaleHeight = true;
+    // End CD - Character Records
 }
 
 public enum SpeciesNaming : byte
diff --git a/Content.Shared/Humanoid/SharedHumanoidAppearanceSystem.cs b/Content.Shared/Humanoid/SharedHumanoidAppearanceSystem.cs
index 88fd118a50..dc9caafe40 100644
--- a/Content.Shared/Humanoid/SharedHumanoidAppearanceSystem.cs
+++ b/Content.Shared/Humanoid/SharedHumanoidAppearanceSystem.cs
@@ -154,6 +154,8 @@ public abstract class SharedHumanoidAppearanceSystem : EntitySystem
         targetHumanoid.CustomBaseLayers = new(sourceHumanoid.CustomBaseLayers);
         targetHumanoid.MarkingSet = new(sourceHumanoid.MarkingSet);
 
+        targetHumanoid.Height = sourceHumanoid.Height; // CD - Character Records
+
         targetHumanoid.Gender = sourceHumanoid.Gender;
         if (TryComp<GrammarComponent>(target, out var grammar))
             grammar.Gender = sourceHumanoid.Gender;
@@ -417,6 +419,7 @@ public abstract class SharedHumanoidAppearanceSystem : EntitySystem
         }
 
         humanoid.Age = profile.Age;
+        humanoid.Height = profile.Height; // CD - Character Records
 
         humanoid.LastProfileLoaded = profile; // DeltaV - let paradox anomaly be cloned
 
diff --git a/Content.Shared/Preferences/HumanoidCharacterProfile.cs b/Content.Shared/Preferences/HumanoidCharacterProfile.cs
index b5b1064dc9..974f3b0f98 100644
--- a/Content.Shared/Preferences/HumanoidCharacterProfile.cs
+++ b/Content.Shared/Preferences/HumanoidCharacterProfile.cs
@@ -15,6 +15,7 @@ using Robust.Shared.Prototypes;
 using Robust.Shared.Random;
 using Robust.Shared.Serialization;
 using Robust.Shared.Utility;
+using Content.Shared._CD.Records; // CD - Character Records
 
 namespace Content.Shared.Preferences
 {
@@ -135,6 +136,14 @@ namespace Content.Shared.Preferences
         public PreferenceUnavailableMode PreferenceUnavailable { get; private set; } =
             PreferenceUnavailableMode.SpawnAsOverflow;
 
+        // Begin CD - Character records
+        [DataField("cosmaticDriftCharacterHeight")]
+        public float Height = 1f;
+
+        [DataField("cosmaticDriftCharacterRecords")]
+        public PlayerProvidedCharacterRecords? CDCharacterRecords;
+        // End CD - Character records
+
         public HumanoidCharacterProfile(
             string name,
             string flavortext,
@@ -148,7 +157,12 @@ namespace Content.Shared.Preferences
             PreferenceUnavailableMode preferenceUnavailable,
             HashSet<ProtoId<AntagPrototype>> antagPreferences,
             HashSet<ProtoId<TraitPrototype>> traitPreferences,
-            Dictionary<string, RoleLoadout> loadouts)
+            Dictionary<string, RoleLoadout> loadouts,
+            // Begin CD - Character Records
+            float height,
+            PlayerProvidedCharacterRecords? cdCharacterRecords
+            // End CD - Character Records
+        )
         {
             Name = name;
             FlavorText = flavortext;
@@ -163,6 +177,10 @@ namespace Content.Shared.Preferences
             _antagPreferences = antagPreferences;
             _traitPreferences = traitPreferences;
             _loadouts = loadouts;
+            // Begin CD - Character Records
+            Height = height;
+            CDCharacterRecords = cdCharacterRecords;
+            // End CD - Character Records
 
             var hasHighPrority = false;
             foreach (var (key, value) in _jobPriorities)
@@ -193,7 +211,9 @@ namespace Content.Shared.Preferences
                 other.PreferenceUnavailable,
                 new HashSet<ProtoId<AntagPrototype>>(other.AntagPreferences),
                 new HashSet<ProtoId<TraitPrototype>>(other.TraitPreferences),
-                new Dictionary<string, RoleLoadout>(other.Loadouts))
+                new Dictionary<string, RoleLoadout>(other.Loadouts),
+                other.Height, // CD - Character Records
+                other.CDCharacterRecords) // CD - Character Records
         {
         }
 
@@ -241,10 +261,12 @@ namespace Content.Shared.Preferences
 
             var sex = Sex.Unsexed;
             var age = 18;
+            var height = 1f; // CD - Character Records
             if (prototypeManager.TryIndex<SpeciesPrototype>(species, out var speciesPrototype))
             {
                 sex = random.Pick(speciesPrototype.Sexes);
                 age = random.Next(speciesPrototype.MinAge, speciesPrototype.OldAge); // people don't look and keep making 119 year old characters with zero rp, cap it at middle aged
+                height = MathF.Round(random.NextFloat(speciesPrototype.MinHeight, speciesPrototype.MaxHeight), 2); // CD - Character Records
             }
 
             var gender = Gender.Epicene;
@@ -269,6 +291,7 @@ namespace Content.Shared.Preferences
                 Gender = gender,
                 Species = species,
                 Appearance = HumanoidCharacterAppearance.Random(species, sex),
+                Height = height,
             };
         }
 
@@ -313,6 +336,18 @@ namespace Content.Shared.Preferences
             return new(this) { SpawnPriority = spawnPriority };
         }
 
+        // Begin CD - Character Records
+        public HumanoidCharacterProfile WithHeight(float height)
+        {
+            return new(this) { Height = height };
+        }
+
+        public HumanoidCharacterProfile WithCDCharacterRecords(PlayerProvidedCharacterRecords records)
+        {
+            return new HumanoidCharacterProfile(this) { CDCharacterRecords = records };
+        }
+        // End CD - Character Records
+
         public HumanoidCharacterProfile WithJobPriorities(IEnumerable<KeyValuePair<ProtoId<JobPrototype>, JobPriority>> jobPriorities)
         {
             var dictionary = new Dictionary<ProtoId<JobPrototype>, JobPriority>(jobPriorities);
@@ -479,6 +514,9 @@ namespace Content.Shared.Preferences
             if (!_traitPreferences.SequenceEqual(other._traitPreferences)) return false;
             if (!Loadouts.SequenceEqual(other.Loadouts)) return false;
             if (FlavorText != other.FlavorText) return false;
+            if (Height != other.Height) return false; // CD
+            if (CDCharacterRecords != null && other.CDCharacterRecords != null && // CD
+               !CDCharacterRecords.MemberwiseEquals(other.CDCharacterRecords)) return false; // CD
             return Appearance.MemberwiseEquals(other.Appearance);
         }
 
@@ -558,6 +596,12 @@ namespace Content.Shared.Preferences
                 flavortext = FormattedMessage.RemoveMarkupOrThrow(FlavorText);
             }
 
+            // Begin CD - Character Records
+            var height = Height;
+            if (speciesPrototype != null)
+                height = Math.Clamp(MathF.Round(Height, 2), speciesPrototype.MinHeight, speciesPrototype.MaxHeight);
+            // End CD - Character Records
+
             var appearance = HumanoidCharacterAppearance.EnsureValid(Appearance, Species, Sex);
 
             var prefsUnavailableMode = PreferenceUnavailable switch
@@ -627,6 +671,18 @@ namespace Content.Shared.Preferences
             _traitPreferences.Clear();
             _traitPreferences.UnionWith(GetValidTraits(traits, prototypeManager));
 
+            // Begin CD - Character Records
+            Height = height;
+            if (CDCharacterRecords == null)
+            {
+                CDCharacterRecords = PlayerProvidedCharacterRecords.DefaultRecords();
+            }
+            else
+            {
+                CDCharacterRecords!.EnsureValid();
+            }
+            // End CD - Character Records
+
             // Checks prototypes exist for all loadouts and dump / set to default if not.
             var toRemove = new ValueList<string>();
 
@@ -722,6 +778,7 @@ namespace Content.Shared.Preferences
             hashCode.Add(Appearance);
             hashCode.Add((int)SpawnPriority);
             hashCode.Add((int)PreferenceUnavailable);
+            hashCode.Add(Height); // CD - Character Records
             return hashCode.ToHashCode();
         }
 
diff --git a/Content.Shared/_CD/Records/FullCharacterRecords.cs b/Content.Shared/_CD/Records/FullCharacterRecords.cs
new file mode 100644
index 0000000000..cfd06e0c11
--- /dev/null
+++ b/Content.Shared/_CD/Records/FullCharacterRecords.cs
@@ -0,0 +1,94 @@
+using Content.Shared.Humanoid;
+using Robust.Shared.Enums;
+using Robust.Shared.Serialization;
+
+namespace Content.Shared._CD.Records;
+
+/// <summary>
+/// Contains the full records information, not just stuff that is in the database.
+/// </summary>
+[Serializable, NetSerializable]
+public sealed class FullCharacterRecords(
+    PlayerProvidedCharacterRecords pRecords,
+    uint? stationRecordsKey,
+    string name,
+    int age,
+    string jobTitle,
+    string jobIcon,
+    string species,
+    Gender gender,
+    Sex sex,
+    string? fingerprint,
+    string? dna,
+    EntityUid? owner = null)
+{
+    [ViewVariables]
+    public PlayerProvidedCharacterRecords PRecords = pRecords;
+
+    /// <summary>
+    /// Key for the equivalent entry in the station records
+    ///
+    /// Sadly, this has to be a uint because StationRecordsKey is not serializable
+    /// </summary>
+    [ViewVariables]
+    public uint? StationRecordsKey = stationRecordsKey;
+
+    /// <summary>
+    ///     Name tied to this record.
+    /// </summary>
+    [ViewVariables]
+    public string Name = name;
+
+    /// <summary>
+    ///     Age of the person that this record represents.
+    /// </summary>
+    [ViewVariables]
+    public int Age = age;
+
+    /// <summary>
+    ///     Job title tied to this record.
+    /// </summary>
+    [ViewVariables]
+    public string JobTitle = jobTitle;
+
+    /// <summary>
+    ///     Job icon tied to this record.
+    /// </summary>
+    [ViewVariables]
+    public string JobIcon = jobIcon;
+
+    /// <summary>
+    ///     Species tied to this record.
+    /// </summary>
+    [ViewVariables]
+    public string Species = species;
+
+    /// <summary>
+    ///     Gender identity tied to this record.
+    /// </summary>
+    [ViewVariables]
+    public Gender Gender = gender;
+
+    /// <summary>
+    ///     Sex identity tied to this record.
+    /// </summary>
+    [ViewVariables]
+    public Sex Sex = sex;
+
+    [ViewVariables]
+    public string? Fingerprint = fingerprint;
+
+    /// <summary>
+    ///     DNA of the person.
+    /// </summary>
+    [ViewVariables]
+    // ReSharper disable once InconsistentNaming
+    public string? DNA = dna;
+
+    /// <summary>
+    /// The entity that owns this record. Should always nonnull inside CharacterRecordsComponent. This field should not be accessed client side.
+    /// </summary>
+    [ViewVariables]
+    [NonSerialized]
+    public EntityUid? Owner = owner;
+}
diff --git a/Content.Shared/_CD/Records/PlayerProvidedCharacterRecords.cs b/Content.Shared/_CD/Records/PlayerProvidedCharacterRecords.cs
new file mode 100644
index 0000000000..4867f41a1e
--- /dev/null
+++ b/Content.Shared/_CD/Records/PlayerProvidedCharacterRecords.cs
@@ -0,0 +1,268 @@
+using System.Linq;
+using System.Text.Json.Serialization;
+using Robust.Shared.Serialization;
+
+namespace Content.Shared._CD.Records;
+
+/// <summary>
+/// Contains Cosmatic Drift records that can be changed in the character editor. This is stored on the character's profile.
+/// </summary>
+[DataDefinition]
+[Serializable, NetSerializable]
+public sealed partial class PlayerProvidedCharacterRecords
+{
+    public const int TextMedLen = 64;
+    public const int TextVeryLargeLen = 4096;
+
+    /* Basic info */
+
+    // Additional data is fetched from the Profile
+
+    // All
+    [DataField]
+    public int Height { get; private set; }
+    public const int MaxHeight = 800;
+
+    [DataField]
+    public int Weight { get; private set; }
+    public const int MaxWeight = 300;
+
+    [DataField]
+    public string EmergencyContactName { get; private set; }
+
+    // Employment
+    [DataField]
+    public bool HasWorkAuthorization { get; private set; }
+
+    // Security
+    [DataField]
+    public string IdentifyingFeatures { get; private set; }
+
+    // Medical
+    [DataField]
+    public string Allergies { get; private set; }
+    [DataField]
+    public string DrugAllergies { get; private set; }
+    [DataField]
+    public string PostmortemInstructions { get; private set; }
+    // history, prescriptions, etc. would be a record below
+
+    // "incidents"
+    [DataField, JsonIgnore]
+    public List<RecordEntry> MedicalEntries { get; private set; }
+    [DataField, JsonIgnore]
+    public List<RecordEntry> SecurityEntries { get; private set; }
+    [DataField, JsonIgnore]
+    public List<RecordEntry> EmploymentEntries { get; private set; }
+
+    [DataDefinition]
+    [Serializable, NetSerializable]
+    public sealed partial class RecordEntry
+    {
+        [DataField]
+        public string Title { get; private set; }
+        // players involved, can be left blank (or with a generic "CentCom" etc.) for backstory related issues
+        [DataField]
+        public string Involved { get; private set; }
+        // Longer description of events.
+        [DataField]
+        public string Description { get; private set; }
+
+        public RecordEntry(string title, string involved, string desc)
+        {
+            Title = title;
+            Involved = involved;
+            Description = desc;
+        }
+
+        public RecordEntry(RecordEntry other)
+        : this(other.Title, other.Involved, other.Description)
+        {
+        }
+
+        public bool MemberwiseEquals(RecordEntry other)
+        {
+            return Title == other.Title && Involved == other.Involved && Description == other.Description;
+        }
+
+        public void EnsureValid()
+        {
+            Title = ClampString(Title, TextMedLen);
+            Involved = ClampString(Involved, TextMedLen);
+            Description = ClampString(Description, TextVeryLargeLen);
+        }
+    }
+
+    public PlayerProvidedCharacterRecords(
+        bool hasWorkAuthorization,
+        int height, int weight,
+        string emergencyContactName,
+        string identifyingFeatures,
+        string allergies, string drugAllergies,
+        string postmortemInstructions,
+        List<RecordEntry> medicalEntries, List<RecordEntry> securityEntries, List<RecordEntry> employmentEntries)
+    {
+        HasWorkAuthorization = hasWorkAuthorization;
+        Height = height;
+        Weight = weight;
+        EmergencyContactName = emergencyContactName;
+        IdentifyingFeatures = identifyingFeatures;
+        Allergies = allergies;
+        DrugAllergies = drugAllergies;
+        PostmortemInstructions = postmortemInstructions;
+        MedicalEntries = medicalEntries;
+        SecurityEntries = securityEntries;
+        EmploymentEntries = employmentEntries;
+    }
+
+    public PlayerProvidedCharacterRecords(PlayerProvidedCharacterRecords other)
+    {
+        Height = other.Height;
+        Weight = other.Weight;
+        EmergencyContactName = other.EmergencyContactName;
+        HasWorkAuthorization = other.HasWorkAuthorization;
+        IdentifyingFeatures = other.IdentifyingFeatures;
+        Allergies = other.Allergies;
+        DrugAllergies = other.DrugAllergies;
+        PostmortemInstructions = other.PostmortemInstructions;
+        MedicalEntries = other.MedicalEntries.Select(x => new RecordEntry(x)).ToList();
+        SecurityEntries = other.SecurityEntries.Select(x => new RecordEntry(x)).ToList();
+        EmploymentEntries = other.EmploymentEntries.Select(x => new RecordEntry(x)).ToList();
+    }
+
+    public static PlayerProvidedCharacterRecords DefaultRecords()
+    {
+        return new PlayerProvidedCharacterRecords(
+            hasWorkAuthorization: true,
+            height: 170, weight: 70,
+            emergencyContactName: "",
+            identifyingFeatures: "",
+            allergies: "None",
+            drugAllergies: "None",
+            postmortemInstructions: "Return home",
+            medicalEntries: new List<RecordEntry>(),
+            securityEntries: new List<RecordEntry>(),
+            employmentEntries: new List<RecordEntry>()
+        );
+    }
+
+    public bool MemberwiseEquals(PlayerProvidedCharacterRecords other)
+    {
+        // This is ugly but is only used for integration tests.
+        var test = Height == other.Height
+                   && Weight == other.Weight
+                   && EmergencyContactName == other.EmergencyContactName
+                   && HasWorkAuthorization == other.HasWorkAuthorization
+                   && IdentifyingFeatures == other.IdentifyingFeatures
+                   && Allergies == other.Allergies
+                   && DrugAllergies == other.DrugAllergies
+                   && PostmortemInstructions == other.PostmortemInstructions;
+        if (!test)
+            return false;
+        if (MedicalEntries.Count != other.MedicalEntries.Count)
+            return false;
+        if (SecurityEntries.Count != other.SecurityEntries.Count)
+            return false;
+        if (EmploymentEntries.Count != other.EmploymentEntries.Count)
+            return false;
+        if (MedicalEntries.Where((t, i) => !t.MemberwiseEquals(other.MedicalEntries[i])).Any())
+        {
+            return false;
+        }
+        if (SecurityEntries.Where((t, i) => !t.MemberwiseEquals(other.SecurityEntries[i])).Any())
+        {
+            return false;
+        }
+        if (EmploymentEntries.Where((t, i) => !t.MemberwiseEquals(other.EmploymentEntries[i])).Any())
+        {
+            return false;
+        }
+
+        return true;
+    }
+
+    private static string ClampString(string str, int maxLen)
+    {
+        if (str.Length > maxLen)
+        {
+            return str[..maxLen];
+        }
+        return str;
+    }
+
+    private static void EnsureValidEntries(List<RecordEntry> entries)
+    {
+        foreach (var entry in entries)
+        {
+            entry.EnsureValid();
+        }
+    }
+
+    /// <summary>
+    /// Clamp invalid entries to valid values
+    /// </summary>
+    public void EnsureValid()
+    {
+        Height = Math.Clamp(Height, 0, MaxHeight);
+        Weight = Math.Clamp(Weight, 0, MaxWeight);
+        EmergencyContactName =
+            ClampString(EmergencyContactName, TextMedLen);
+        IdentifyingFeatures = ClampString(IdentifyingFeatures, TextMedLen);
+        Allergies = ClampString(Allergies, TextMedLen);
+        DrugAllergies = ClampString(DrugAllergies, TextMedLen);
+        PostmortemInstructions = ClampString(PostmortemInstructions, TextMedLen);
+
+        EnsureValidEntries(EmploymentEntries);
+        EnsureValidEntries(MedicalEntries);
+        EnsureValidEntries(SecurityEntries);
+    }
+    public PlayerProvidedCharacterRecords WithHeight(int height)
+    {
+        return new(this) { Height = height };
+    }
+    public PlayerProvidedCharacterRecords WithWeight(int weight)
+    {
+        return new(this) { Weight = weight };
+    }
+    public PlayerProvidedCharacterRecords WithWorkAuth(bool auth)
+    {
+        return new(this) { HasWorkAuthorization = auth };
+    }
+    public PlayerProvidedCharacterRecords WithContactName(string name)
+    {
+        return new(this) { EmergencyContactName = name};
+    }
+    public PlayerProvidedCharacterRecords WithIdentifyingFeatures(string feat)
+    {
+        return new(this) { IdentifyingFeatures = feat};
+    }
+    public PlayerProvidedCharacterRecords WithAllergies(string s)
+    {
+        return new(this) { Allergies = s };
+    }
+    public PlayerProvidedCharacterRecords WithDrugAllergies(string s)
+    {
+        return new(this) { DrugAllergies = s };
+    }
+    public PlayerProvidedCharacterRecords WithPostmortemInstructions(string s)
+    {
+        return new(this) { PostmortemInstructions = s};
+    }
+    public PlayerProvidedCharacterRecords WithEmploymentEntries(List<RecordEntry> entries)
+    {
+        return new(this) { EmploymentEntries = entries};
+    }
+    public PlayerProvidedCharacterRecords WithMedicalEntries(List<RecordEntry> entries)
+    {
+        return new(this) { MedicalEntries = entries};
+    }
+    public PlayerProvidedCharacterRecords WithSecurityEntries(List<RecordEntry> entries)
+    {
+        return new(this) { SecurityEntries = entries};
+    }
+}
+
+public enum CharacterRecordType : byte
+{
+    Employment, Medical, Security
+}
diff --git a/Content.Shared/_CD/Records/SharedCharacterRecordConsole.cs b/Content.Shared/_CD/Records/SharedCharacterRecordConsole.cs
new file mode 100644
index 0000000000..59de5bcb77
--- /dev/null
+++ b/Content.Shared/_CD/Records/SharedCharacterRecordConsole.cs
@@ -0,0 +1,80 @@
+using Content.Shared.Security;
+using Content.Shared.StationRecords;
+using Robust.Shared.Serialization;
+
+namespace Content.Shared._CD.Records;
+
+[Serializable, NetSerializable]
+public enum CharacterRecordConsoleKey : byte
+{
+    Key
+}
+
+[Serializable, NetSerializable]
+public enum RecordConsoleType : byte
+{
+    Security,
+    Medical,
+    Employment,
+    /// <summary>
+    /// Admin console has the functionality of all other types and has some additional admin related functionality
+    /// </summary>
+    Admin
+}
+
+[Serializable, NetSerializable]
+public sealed class CharacterRecordConsoleState : BoundUserInterfaceState
+{
+    [Serializable, NetSerializable]
+    public struct CharacterInfo
+    {
+        public string CharacterDisplayName;
+        public uint? StationRecordKey;
+    }
+
+    public RecordConsoleType ConsoleType { get; set; }
+
+    /// <summary>
+    /// Character selected in the console
+    /// </summary>
+    public uint? SelectedIndex { get; set; } = null;
+
+    /// <summary>
+    /// List of names+station record keys to display in the listing
+    /// </summary>
+    public Dictionary<uint, CharacterInfo>? CharacterList { get; set; }
+
+    /// <summary>
+    /// The contents of the selected record
+    /// </summary>
+    public FullCharacterRecords? SelectedRecord { get; set; } = null;
+
+    public StationRecordsFilter? Filter { get; set; } = null;
+
+    /// <summary>
+    /// Security status of the selected record
+    /// </summary>
+    public (SecurityStatus, string?)? SelectedSecurityStatus = null;
+}
+
+[Serializable, NetSerializable]
+public sealed class CharacterRecordsConsoleFilterMsg : BoundUserInterfaceMessage
+{
+    public readonly StationRecordsFilter? Filter;
+
+    public CharacterRecordsConsoleFilterMsg(StationRecordsFilter? filter)
+    {
+        Filter = filter;
+    }
+}
+
+[Serializable, NetSerializable]
+public sealed class CharacterRecordConsoleSelectMsg : BoundUserInterfaceMessage
+{
+    public readonly uint? CharacterRecordKey;
+
+    public CharacterRecordConsoleSelectMsg(uint? characterRecordKey)
+    {
+        CharacterRecordKey = characterRecordKey;
+    }
+}
diff --git a/Resources/Locale/en-US/_CD/admin/admin.ftl b/Resources/Locale/en-US/_CD/admin/admin.ftl
new file mode 100644
index 0000000000..eb9f2d8590
--- /dev/null
+++ b/Resources/Locale/en-US/_CD/admin/admin.ftl
@@ -0,0 +1,11 @@
+admin-player-actions-window-cd-record-purge = Modify Character Records
+cd-actions-admin-modify-records = Modify Character Records
+cd-actions-admin-modify-reset = Reset Records
+cd-actions-admin-modify-del-entry = Delete Entry
+
+cd-eventpreferencepanel-title = Event Preference View
+cd-eventpreferencepanel-player = Player: {$player}
+cd-eventpreferencepanel-character = Character: {$characterName}
+
+cmd-eventpreferences-help = Usage: eventpreferences <name>
+cmd-eventpreferences-desc = Displays a player's current character's event preferences (i.e. antags)
diff --git a/Resources/Locale/en-US/_CD/guidebook/guides.ftl b/Resources/Locale/en-US/_CD/guidebook/guides.ftl
new file mode 100644
index 0000000000..df2cfa5939
--- /dev/null
+++ b/Resources/Locale/en-US/_CD/guidebook/guides.ftl
@@ -0,0 +1,16 @@
+guide-entry-cd-records = Character Records
+guide-entry-rules-cd = Cosmatic Drift Rules
+
+guide-entry-cd = Cosmatic Drift Content
+guide-entry-cd-newplayer = Welcome to Cosmatic Drift!
+
+guide-entry-rules-ic = In Character Policy
+guide-entry-rules-sop-core = Standard Operating Procedure
+guide-entry-rules-sop-restricted = List of Restricted Items
+guide-entry-rules-sop-command = Command
+guide-entry-rules-sop-sec = Security
+guide-entry-rules-sop-engi = Engineering
+guide-entry-rules-sop-med = Medical
+guide-entry-rules-sop-sci = Science
+guide-entry-rules-sop-cargo = Cargo
+guide-entry-rules-sop-service = Service
diff --git a/Resources/Locale/en-US/_CD/preferences/ui/humanoid-profile-editor.ftl b/Resources/Locale/en-US/_CD/preferences/ui/humanoid-profile-editor.ftl
new file mode 100644
index 0000000000..1c2ae70819
--- /dev/null
+++ b/Resources/Locale/en-US/_CD/preferences/ui/humanoid-profile-editor.ftl
@@ -0,0 +1,2 @@
+humanoid-profile-editor-height-label = Height:
+humanoid-profile-editor-reset-height-button = Reset
diff --git a/Resources/Locale/en-US/_CD/records/corrections.ftl b/Resources/Locale/en-US/_CD/records/corrections.ftl
new file mode 100644
index 0000000000..16349c7e71
--- /dev/null
+++ b/Resources/Locale/en-US/_CD/records/corrections.ftl
@@ -0,0 +1,5 @@
+ent-CriminalRecordsComputerCircuitboard = security records computer board
+    .desc = A computer printed circuit board for a security records computer.
+
+ent-StationRecordsComputerCircuitboard = employment records computer board
+    .desc = A computer printed circuit board for a employment records computer.
diff --git a/Resources/Locale/en-US/_CD/records/editor.ftl b/Resources/Locale/en-US/_CD/records/editor.ftl
new file mode 100644
index 0000000000..ffe62cd6ef
--- /dev/null
+++ b/Resources/Locale/en-US/_CD/records/editor.ftl
@@ -0,0 +1,40 @@
+# Records editor
+humanoid-profile-editor-cd-records-tab = Records
+
+# General
+humanoid-profile-editor-cd-records-height = Height (cm):
+humanoid-profile-editor-cd-records-weight = Weight (kg):
+humanoid-profile-editor-cd-records-contact-name = Emergency Contact Names(s):
+
+# Employment
+humanoid-profile-editor-cd-records-employment = Employment
+humanoid-profile-editor-cd-records-work-authorization = Work Authorization:
+
+# Security
+humanoid-profile-editor-cd-records-identifying-features = Identifying Features:
+
+# Medical
+humanoid-profile-editor-cd-records-allergies = Allergies:
+humanoid-profile-editor-cd-records-drug-allergies = Drug Allergies:
+humanoid-profile-editor-cd-records-postmortem = Postmortem Instructions:
+
+# Entries
+humanoid-profile-editor-cd-records-add-entry = Add Entry
+humanoid-profile-editor-cd-records-edit-entry = Edit Entry
+humanoid-profile-editor-cd-records-view-entry = View Entry
+humanoid-profile-editor-cd-records-remove-entry = Remove Entry
+humanoid-profile-editor-cd-records-up = Up
+humanoid-profile-editor-cd-records-down = Down
+
+cd-records-entry-edit-popup-title = View/Edit Entry
+cd-records-entry-edit-popup-save = Save
+cd-records-entry-default-title = Untitled Entry
+
+cd-records-entry-edit-popup-title-placeholder = Entry Title
+cd-records-entry-edit-popup-involved-placeholder = Author(s)
+cd-records-entry-edit-popup-description-placeholder = Description
+
+cd-records-entry-edit-popup-title-required = Title is required
+cd-records-entry-edit-popup-involved-required = Author(s) is required
+cd-records-entry-edit-popup-description-required = Description is required
+cd-records-entry-edit-popup-description-too-long = Description is too long! ({$current}/{$max} characters)
diff --git a/Resources/Locale/en-US/_CD/records/viewer.ftl b/Resources/Locale/en-US/_CD/records/viewer.ftl
new file mode 100644
index 0000000000..77387daede
--- /dev/null
+++ b/Resources/Locale/en-US/_CD/records/viewer.ftl
@@ -0,0 +1,26 @@
+cd-character-records-viewer-title-employ = Employment Records
+cd-character-records-viewer-title-sec = Security Records
+cd-character-records-viewer-title-med = Medical Records
+
+cd-record-viewer-empty-state = Cannot fetch records.
+cd-record-viewer-no-record-selected = Please select record.
+
+cd-character-records-viewer-record-age = Age:
+cd-character-records-viewer-record-job = Job:
+cd-character-records-viewer-record-gender = Gender:
+cd-character-records-viewer-record-species = Species:
+
+cd-character-records-viewer-record-sec-fingerprint = Fingerprint:
+cd-character-records-viewer-record-sec-dna = DNA:
+
+cd-character-records-viewer-unknown = ERROR UNKNOWN
+
+cd-character-records-viewer-record-med-sex = Sex:
+
+cd-character-records-viewer-view-entry = View
+cd-records-entry-view-popup-title = View Entry
+
+cd-character-records-entry-view-title = Title:
+cd-character-records-entry-view-involved = Author(s):
+
+cd-character-records-viewer-setwanted-placeholder = Reason
diff --git a/Resources/Prototypes/Entities/Mobs/Player/admin_ghost.yml b/Resources/Prototypes/Entities/Mobs/Player/admin_ghost.yml
index 5d9acaf1c4..1e6c2c23f1 100644
--- a/Resources/Prototypes/Entities/Mobs/Player/admin_ghost.yml
+++ b/Resources/Prototypes/Entities/Mobs/Player/admin_ghost.yml
@@ -52,6 +52,10 @@
         type: CargoOrderConsoleBoundUserInterface
       enum.CrewMonitoringUIKey.Key:
         type: CrewMonitoringBoundUserInterface
+      # Begin CD - Character Records
+      enum.CharacterRecordConsoleKey.Key:
+        type: CharacterRecordConsoleBoundUserInterface
+      # End CD - Character Records
       enum.GeneralStationRecordConsoleKey.Key:
       # who the fuck named this bruh
         type: GeneralStationRecordConsoleBoundUserInterface
@@ -69,6 +73,10 @@
         toggleAction: ActionAGhostShowCrewMonitoring
       enum.GeneralStationRecordConsoleKey.Key:
         toggleAction: ActionAGhostShowStationRecords
+      # Begin CD - Character Records
+      enum.CharacterRecordConsoleKey.Key:
+        toggleAction: ActionAGhostShowCharacterRecords
+      # End CD - Character Records
   - type: SolarControlConsole # look ma i AM the computer!
   - type: CommunicationsConsole
     title: comms-console-announcement-title-centcom
@@ -83,6 +91,11 @@
   - type: CrewMonitoringConsole
   - type: GeneralStationRecordConsole
     canDeleteEntries: true
+  # Begin CD - Character Records
+  - type: CharacterRecordConsole
+    consoleType: Admin
+  - type: CriminalRecordsConsole
+  # End CD - Character Records
   - type: DeviceNetwork
     deviceNetId: Wireless
     receiveFrequencyId: CrewMonitor
@@ -174,3 +187,18 @@
     keywords: [ "AI", "console", "interface" ]
     priority: -7
     event: !type:ToggleIntrinsicUIEvent { key: enum.GeneralStationRecordConsoleKey.Key }
+
+# Begin CD - Character Records
+- type: entity
+  id: ActionAGhostShowCharacterRecords
+  name: Character Records Interface
+  description: View all of the character records
+  categories: [ HideSpawnMenu ]
+  components:
+  - type: InstantAction
+    icon: { sprite: Structures/Machines/parts.rsi, state: box_0 }
+    iconOn: Structures/Machines/parts.rsi/box_2.png
+    keywords: [ "AI", "console", "interface" ]
+    priority: -10
+    event: !type:ToggleIntrinsicUIEvent { key: enum.CharacterRecordConsoleKey.Key }
+# Edn CD - Character Records
diff --git a/Resources/Prototypes/Entities/Structures/Machines/Computers/computers.yml b/Resources/Prototypes/Entities/Structures/Machines/Computers/computers.yml
index 42d11fd876..959991e64a 100644
--- a/Resources/Prototypes/Entities/Structures/Machines/Computers/computers.yml
+++ b/Resources/Prototypes/Entities/Structures/Machines/Computers/computers.yml
@@ -360,6 +360,16 @@
     color: "#1f8c28"
   - type: Computer
     board: MedicalRecordsComputerCircuitboard
+  # Begin CD - Character Records
+  - type: CharacterRecordConsole
+    consoleType: Medical
+  - type: UserInterface
+    interfaces:
+      enum.CharacterRecordConsoleKey.Key:
+        type: CharacterRecordConsoleBoundUserInterface
+  - type: ActivatableUI
+    key: enum.CharacterRecordConsoleKey.Key
+  # End CD - Character Records
 
 - type: entity
   parent: BaseComputerAiAccess
@@ -370,12 +380,18 @@
   - type: CriminalRecordsConsole
   - type: UserInterface
     interfaces:
-      enum.CriminalRecordsConsoleKey.Key:
-        type: CriminalRecordsConsoleBoundUserInterface
+      # Begin CD - Character Records
+      enum.CharacterRecordConsoleKey.Key:
+        type: CharacterRecordConsoleBoundUserInterface
+      # End CD - Character Records
       enum.WiresUiKey.Key:
         type: WiresBoundUserInterface
+  # Begin CD - Character Records
+  - type: CharacterRecordConsole
+    consoleType: Security
   - type: ActivatableUI
-    key: enum.CriminalRecordsConsoleKey.Key
+    key: enum.CharacterRecordConsoleKey.Key
+  # End CD - Character Records
   - type: Sprite
     layers:
     - map: ["computerLayerBody"]
@@ -409,12 +425,18 @@
   - type: GeneralStationRecordConsole
   - type: UserInterface
     interfaces:
-        enum.GeneralStationRecordConsoleKey.Key:
-          type: GeneralStationRecordConsoleBoundUserInterface
+        # Begin CD - Character Records
+        enum.CharacterRecordConsoleKey.Key:
+          type: CharacterRecordConsoleBoundUserInterface
+        # End CD - Character Records
         enum.WiresUiKey.Key:
           type: WiresBoundUserInterface
+  # Begin CD - Character Records
+  - type: CharacterRecordConsole
+    consoleType: Employment
   - type: ActivatableUI
-    key: enum.GeneralStationRecordConsoleKey.Key
+    key: enum.CharacterRecordConsoleKey.Key
+  # End CD - Character Records
   - type: PointLight
     radius: 1.5
     energy: 1.6
diff --git a/Resources/Prototypes/Guidebook/newplayer.yml b/Resources/Prototypes/Guidebook/newplayer.yml
index 9b1430cb15..4fc6f28ab1 100644
--- a/Resources/Prototypes/Guidebook/newplayer.yml
+++ b/Resources/Prototypes/Guidebook/newplayer.yml
@@ -25,7 +25,8 @@
   text: "/ServerInfo/Guidebook/NewPlayer/CharacterCreation.xml"
   children:
   - YourFirstCharacter
-  - Species
+  - Species 
+  - Records # DeltaV - CD records page goes here
 
 - type: guideEntry
   id: YourFirstCharacter
diff --git a/Resources/Prototypes/Nyanotrasen/Species/Oni.yml b/Resources/Prototypes/Nyanotrasen/Species/Oni.yml
index 88ee0825f2..f18e925395 100644
--- a/Resources/Prototypes/Nyanotrasen/Species/Oni.yml
+++ b/Resources/Prototypes/Nyanotrasen/Species/Oni.yml
@@ -11,6 +11,7 @@
   femaleFirstNames: NamesOniFemale
   lastNames: NamesOniLocation
   naming: LastNoFirst
+  baseScale: "1.2, 1.2"
 
 - type: markingPoints
   id: MobOniMarkingLimits
diff --git a/Resources/Prototypes/Nyanotrasen/Species/felinid.yml b/Resources/Prototypes/Nyanotrasen/Species/felinid.yml
index 8a3eb7fa99..47ca8f5b4b 100644
--- a/Resources/Prototypes/Nyanotrasen/Species/felinid.yml
+++ b/Resources/Prototypes/Nyanotrasen/Species/felinid.yml
@@ -7,6 +7,7 @@
   markingLimits: MobFelinidMarkingLimits
   dollPrototype: MobFelinidDummy
   skinColoration: Hues # DeltaV
+  baseScale: "0.8, 0.8"
 
 - type: markingPoints
   id: MobFelinidMarkingLimits
diff --git a/Resources/Prototypes/_CD/Guidebook/features.yml b/Resources/Prototypes/_CD/Guidebook/features.yml
new file mode 100644
index 0000000000..ecd96de7bb
--- /dev/null
+++ b/Resources/Prototypes/_CD/Guidebook/features.yml
@@ -0,0 +1,4 @@
+- type: guideEntry
+  id: Records
+  name: guide-entry-cd-records
+  text: "/ServerInfo/Guidebook/_CD/Records.xml"
\ No newline at end of file
diff --git a/Resources/Prototypes/_DV/Species/harpy.yml b/Resources/Prototypes/_DV/Species/harpy.yml
index 3f47171710..b88da5a8d0 100644
--- a/Resources/Prototypes/_DV/Species/harpy.yml
+++ b/Resources/Prototypes/_DV/Species/harpy.yml
@@ -7,6 +7,7 @@
   markingLimits: MobHarpyMarkingLimits
   dollPrototype: MobHarpyDummy
   skinColoration: HumanToned
+  baseScale: "0.9, 0.9"
 
 - type: speciesBaseSprites
   id: MobHarpySprites
diff --git a/Resources/Prototypes/_DV/Species/rodentia.yml b/Resources/Prototypes/_DV/Species/rodentia.yml
index e92484d8df..83c350921d 100644
--- a/Resources/Prototypes/_DV/Species/rodentia.yml
+++ b/Resources/Prototypes/_DV/Species/rodentia.yml
@@ -12,6 +12,7 @@
   femaleFirstNames: NamesRodentiaFemale
   lastNames: NamesRodentiaLast
   naming: LastFirst
+  baseScale: "0.8, 0.8"
 
 - type: speciesBaseSprites
   id: MobRodentiaSprites
diff --git a/Resources/Prototypes/_Impstation/Species/thaven.yml b/Resources/Prototypes/_Impstation/Species/thaven.yml
index bb2fc09c9a..9e99e12947 100644
--- a/Resources/Prototypes/_Impstation/Species/thaven.yml
+++ b/Resources/Prototypes/_Impstation/Species/thaven.yml
@@ -15,6 +15,7 @@
   - Male
   - Female
   - Unsexed
+  baseScale: "1, 1.05" # DeltaV - make sure Thaven are still scaled w/ CD records
 
 - type: speciesBaseSprites
   id: MobThavenSprites
diff --git a/Resources/ServerInfo/Guidebook/_CD/Records.xml b/Resources/ServerInfo/Guidebook/_CD/Records.xml
new file mode 100644
index 0000000000..71d9ee4c9a
--- /dev/null
+++ b/Resources/ServerInfo/Guidebook/_CD/Records.xml
@@ -0,0 +1,40 @@
+<Document>
+
+## Character Records
+
+You can create records for you characters in the records tab of the character
+creator. Just simply fill in the values and save. Entries should typically be
+written from the perspective of a CentCom official.
+
+## Employment Entries
+
+Employment Entries should include your characters education, previous jobs, and
+anything that you think NanoTrasen would log about your characters past that is
+not security related.
+
+## Medical Entries
+
+Medical Entries should include anything a doctor should know before treating
+your character, major surgeries, prescriptions, and any psychological evaluations.
+
+## Security Entries
+
+Security Entries should include any major arrests/incidents your character has
+had in their past or while working with NanoTrasen. Do not log minor incidents.
+
+## Accessing Records
+You can access the records of your crewmates in game from their respective consoles.
+
+<Box>
+<GuideEntityEmbed Entity="ComputerMedicalRecords" Caption="Medical"/>
+<GuideEntityEmbed Entity="ComputerCriminalRecords" Caption="Security"/>
+<GuideEntityEmbed Entity="ComputerStationRecords" Caption="Station"/>
+</Box>
+
+It is currently not possible to create new records in game. This is something
+that will be added in the future. If there is something that occurs in the round
+that you think is relevant for a record entry, it is on you to write it at the
+moment. Keep in mind that records should typically be written from the
+perspective of some CentCom official.
+
+</Document>