diff --git a/Content.Client/_DEN/Containers/EntitySystems/ContainerSelectionSystem.cs b/Content.Client/_DEN/Containers/EntitySystems/ContainerSelectionSystem.cs
new file mode 100644
index 0000000000..631676e169
--- /dev/null
+++ b/Content.Client/_DEN/Containers/EntitySystems/ContainerSelectionSystem.cs
@@ -0,0 +1,6 @@
+using Content.Shared._DEN.Containers.EntitySystems;
+using Content.Shared._DEN.Containers.Events;
+
+namespace Content.Client._DEN.Containers.EntitySystems;
+
+public sealed class ContainerSelectionSystem : SharedContainerSelectionSystem;
diff --git a/Content.Client/_DEN/Containers/UI/ContainerSelectionBoundUserInterface.cs b/Content.Client/_DEN/Containers/UI/ContainerSelectionBoundUserInterface.cs
new file mode 100644
index 0000000000..8dc8792b26
--- /dev/null
+++ b/Content.Client/_DEN/Containers/UI/ContainerSelectionBoundUserInterface.cs
@@ -0,0 +1,61 @@
+using Content.Client._DEN.Containers.EntitySystems;
+using Content.Shared._DEN.Containers.Components;
+using Content.Shared._DEN.Containers.Events;
+using Content.Shared.EntityTable;
+using JetBrains.Annotations;
+using Robust.Client.Graphics;
+using Robust.Client.UserInterface;
+using Robust.Client.UserInterface.Controls;
+using Robust.Shared.Prototypes;
+
+namespace Content.Client._DEN.Containers.UI;
+
+[UsedImplicitly]
+public sealed class ContainerSelectionBoundUserInterface : BoundUserInterface
+{
+    private ContainerSelectionWindow? _window;
+
+    public ContainerSelectionBoundUserInterface(EntityUid owner, Enum uiKey) : base(owner, uiKey)
+    {
+        IoCManager.InjectDependencies(this);
+    }
+
+    protected override void Open()
+    {
+        base.Open();
+
+        if (!EntMan.TryGetComponent<EntityTableContainerSelectionComponent>(Owner, out var entityTableSelectComp))
+            return;
+
+        _window = this.CreateWindow<ContainerSelectionWindow>();
+        var controls = ConvertToControls(entityTableSelectComp);
+        _window.SetControls(controls);
+        _window.OpenCentered();
+
+    }
+
+    private IEnumerable<ContainerSelectionControl> ConvertToControls(EntityTableContainerSelectionComponent entityTableSelectComp)
+    {
+        var containers = new ContainerSelectionControl[entityTableSelectComp.Selections.Count];
+        var containerIndex = 0;
+
+        // Create a ContainerSelectionControl for each of the possible selections.
+        foreach (var selection in entityTableSelectComp.Selections)
+        {
+            var selectionControl = new ContainerSelectionControl();
+            selectionControl.SetData(EntMan, selection.SelectionName, selection.Containers);
+            var curIndex = containerIndex;
+            selectionControl.ChooseButton.OnPressed += _ => MakeSelection(curIndex);
+
+            containers[containerIndex++] = selectionControl;
+        }
+
+        return containers;
+    }
+
+    private void MakeSelection(int index)
+    {
+        SendMessage(new ContainerSelectionMessage(index));
+        _window?.Close();
+    }
+}
diff --git a/Content.Client/_DEN/Containers/UI/ContainerSelectionControl.xaml b/Content.Client/_DEN/Containers/UI/ContainerSelectionControl.xaml
new file mode 100644
index 0000000000..09c1228906
--- /dev/null
+++ b/Content.Client/_DEN/Containers/UI/ContainerSelectionControl.xaml
@@ -0,0 +1,27 @@
+<Control xmlns="https://spacestation14.io"
+              xmlns:gfx="clr-namespace:Robust.Client.Graphics;assembly=Robust.Client">
+    <BoxContainer Orientation="Vertical" HorizontalExpand="True">
+        <PanelContainer Margin="4">
+            <PanelContainer.PanelOverride>
+                <gfx:StyleBoxFlat BorderThickness="2" BorderColor="#2F2F2F" />
+            </PanelContainer.PanelOverride>
+
+            <BoxContainer Orientation="Vertical" HorizontalExpand="True">
+                <BoxContainer Orientation="Horizontal" HorizontalExpand="True" Margin="2">
+                    <!-- Set label text in C# -->
+                    <Label Name="HeaderLabel" HorizontalExpand="True" Margin="4" />
+                    <Button Name="ChooseButton" Text="{Loc container-selection-ui-choose-button}" Access="Public"/>
+                </BoxContainer>
+
+                <Collapsible Orientation="Vertical" HorizontalExpand="True" Margin="4">
+                    <CollapsibleHeading Title="{Loc 'container-selection-ui-contents'}" />
+                    <CollapsibleBody HorizontalExpand="True" Margin="6">
+                        <GridContainer Name="EntityGrid" MaxGridWidth="300">
+                            <!-- Populated in C# -->
+                        </GridContainer>
+                    </CollapsibleBody>
+                </Collapsible>
+            </BoxContainer>
+        </PanelContainer>
+    </BoxContainer>
+</Control>
diff --git a/Content.Client/_DEN/Containers/UI/ContainerSelectionControl.xaml.cs b/Content.Client/_DEN/Containers/UI/ContainerSelectionControl.xaml.cs
new file mode 100644
index 0000000000..e9a1fda6aa
--- /dev/null
+++ b/Content.Client/_DEN/Containers/UI/ContainerSelectionControl.xaml.cs
@@ -0,0 +1,43 @@
+using Content.Shared.EntityTable;
+using Content.Shared.EntityTable.EntitySelectors;
+using Robust.Client.AutoGenerated;
+using Robust.Client.UserInterface;
+using Robust.Client.UserInterface.XAML;
+using Robust.Shared.Prototypes;
+
+namespace Content.Client._DEN.Containers.UI;
+
+[GenerateTypedNameReferences]
+public sealed partial class ContainerSelectionControl : Control
+{
+    [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
+
+    public ContainerSelectionControl()
+    {
+        RobustXamlLoader.Load(this);
+        IoCManager.InjectDependencies(this);
+    }
+
+    /// <summary>
+    ///     Set the display data used by this control.
+    /// </summary>
+    /// <param name="entMan">Entity manager (used for retrieving the list of spqwns from EntityTableSelectors)</param>
+    /// <param name="selectionName">The localization string for the selection category.</param>
+    /// <param name="tables">The map of containers to EntityTableSelectors for this selection, used to display the contained entities.</param>
+    public void SetData(IEntityManager entMan, LocId selectionName, Dictionary<string, EntityTableSelector> tables)
+    {
+        HeaderLabel.Text = Loc.GetString(selectionName);
+
+        foreach (var entContainer in tables)
+        {
+            var ctx = new EntityTableContext();
+            foreach (var (proto, _) in entContainer.Value.ListSpawns(entMan, _prototypeManager, ctx))
+            {
+                var protoView = new ContainerSelectionEntityView();
+                protoView.SetEntityPrototype(proto);
+
+                EntityGrid.AddChild(protoView);
+            }
+        }
+    }
+}
diff --git a/Content.Client/_DEN/Containers/UI/ContainerSelectionEntityView.xaml b/Content.Client/_DEN/Containers/UI/ContainerSelectionEntityView.xaml
new file mode 100644
index 0000000000..dabc4da554
--- /dev/null
+++ b/Content.Client/_DEN/Containers/UI/ContainerSelectionEntityView.xaml
@@ -0,0 +1,10 @@
+<Control xmlns="https://spacestation14.io"
+                                 xmlns:gfx="clr-namespace:Robust.Client.Graphics;assembly=Robust.Client"
+                                 Margin="4">
+    <PanelContainer>
+        <PanelContainer.PanelOverride>
+            <gfx:StyleBoxFlat BorderThickness="2" BorderColor="#4f4f4f" />
+        </PanelContainer.PanelOverride>
+        <EntityPrototypeView Name="EntityView" SetSize="32 32" Stretch="Fill" Scale="2 2" />
+    </PanelContainer>
+</Control>
diff --git a/Content.Client/_DEN/Containers/UI/ContainerSelectionEntityView.xaml.cs b/Content.Client/_DEN/Containers/UI/ContainerSelectionEntityView.xaml.cs
new file mode 100644
index 0000000000..6347d770c8
--- /dev/null
+++ b/Content.Client/_DEN/Containers/UI/ContainerSelectionEntityView.xaml.cs
@@ -0,0 +1,24 @@
+using Robust.Client.AutoGenerated;
+using Robust.Client.UserInterface;
+using Robust.Client.UserInterface.XAML;
+using Robust.Shared.Prototypes;
+
+namespace Content.Client._DEN.Containers.UI;
+
+[GenerateTypedNameReferences]
+public sealed partial class ContainerSelectionEntityView : Control
+{
+    public ContainerSelectionEntityView()
+    {
+        RobustXamlLoader.Load(this);
+    }
+
+    /// <summary>
+    /// Sets the displayed prototype.
+    /// </summary>
+    /// <param name="proto">The prototype to display.</param>
+    public void SetEntityPrototype(EntProtoId proto)
+    {
+        EntityView.SetPrototype(proto);
+    }
+}
diff --git a/Content.Client/_DEN/Containers/UI/ContainerSelectionWindow.xaml b/Content.Client/_DEN/Containers/UI/ContainerSelectionWindow.xaml
new file mode 100644
index 0000000000..8baa332ae8
--- /dev/null
+++ b/Content.Client/_DEN/Containers/UI/ContainerSelectionWindow.xaml
@@ -0,0 +1,12 @@
+<controls:FancyWindow xmlns="https://spacestation14.io"
+                xmlns:controls="clr-namespace:Content.Client.UserInterface.Controls"
+                Title="{Loc 'container-selection-ui-title'}"
+                MinWidth="350"
+                MinHeight="500">
+    <BoxContainer Orientation="Vertical">
+        <ScrollContainer HorizontalExpand="True" VerticalExpand="True" HScrollEnabled="False" VScrollEnabled="True">
+            <BoxContainer Name="Options" HorizontalExpand="True" Orientation="Vertical">
+            </BoxContainer>
+        </ScrollContainer>
+    </BoxContainer>
+</controls:FancyWindow>
diff --git a/Content.Client/_DEN/Containers/UI/ContainerSelectionWindow.xaml.cs b/Content.Client/_DEN/Containers/UI/ContainerSelectionWindow.xaml.cs
new file mode 100644
index 0000000000..ef71e7a067
--- /dev/null
+++ b/Content.Client/_DEN/Containers/UI/ContainerSelectionWindow.xaml.cs
@@ -0,0 +1,26 @@
+using Content.Client.UserInterface.Controls;
+using Robust.Client.AutoGenerated;
+using Robust.Client.UserInterface.Controls;
+using Robust.Client.UserInterface.XAML;
+
+namespace Content.Client._DEN.Containers.UI;
+
+[GenerateTypedNameReferences]
+public sealed partial class ContainerSelectionWindow : FancyWindow
+{
+    public ContainerSelectionWindow()
+    {
+        RobustXamlLoader.Load(this);
+        IoCManager.InjectDependencies(this);
+    }
+
+    public void SetControls(IEnumerable<ContainerSelectionControl> controls)
+    {
+        // Remove any old controls to prevent duplicates.
+        Options.RemoveAllChildren();
+        foreach (var control in controls)
+        {
+            Options.AddChild(control);
+        }
+    }
+}
diff --git a/Content.Server/_DEN/Containers/EntitySystems/ContainerSelectionSystem.cs b/Content.Server/_DEN/Containers/EntitySystems/ContainerSelectionSystem.cs
new file mode 100644
index 0000000000..aef6305025
--- /dev/null
+++ b/Content.Server/_DEN/Containers/EntitySystems/ContainerSelectionSystem.cs
@@ -0,0 +1,120 @@
+using System.Linq;
+using System.Numerics;
+using Content.Shared._DEN.Containers.Components;
+using Content.Shared._DEN.Containers.EntitySystems;
+using Content.Shared._DEN.Containers.Events;
+using Content.Shared.ActionBlocker;
+using Content.Shared.Destructible;
+using Content.Shared.EntityTable;
+using Content.Shared.EntityTable.EntitySelectors;
+using Content.Shared.Storage.EntitySystems;
+using Robust.Shared.Containers;
+using Robust.Shared.Map;
+using Robust.Shared.Random;
+
+namespace Content.Server._DEN.Containers.EntitySystems;
+
+public sealed partial class ContainerSelectionSystem : SharedContainerSelectionSystem
+{
+    [Dependency] private readonly SharedContainerSystem _containers = default!;
+    [Dependency] private readonly EntityTableSystem _entityTable = default!;
+    [Dependency] private readonly SharedTransformSystem _transform = default!;
+    [Dependency] private readonly ActionBlockerSystem _blockerSystem = default!;
+    [Dependency] private readonly SharedUserInterfaceSystem _uiSystem = default!;
+    [Dependency] private readonly IRobustRandom _random = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+        
+        SubscribeLocalEvent<EntityTableContainerSelectionComponent, ContainerSelectionMessage>(OnContainerSelectionMessage);
+        SubscribeLocalEvent<EntityTableContainerSelectionComponent, DestructionEventArgs>(OnDestruction,
+            before: [typeof(SharedStorageSystem)]);
+    }
+
+    private void OnContainerSelectionMessage(Entity<EntityTableContainerSelectionComponent> ent, ref ContainerSelectionMessage message)
+    {
+        // Can the user even reach the container anymore?
+        if (!_blockerSystem.CanInteract(message.Actor, ent))
+            return;
+
+        // Don't allow invalid selections.
+        if (ent.Comp.Selections.Count < message.SelectionIndex)
+            return;
+
+        var selection = ent.Comp.Selections[message.SelectionIndex];
+        OnSelectionMade(ent, selection);
+    }
+
+    private void OnDestruction(Entity<EntityTableContainerSelectionComponent> ent,
+        ref DestructionEventArgs args)
+    {
+        // If no selection has been made but our container is destroyed, populate the contents with one of the choices
+        // at random so that the container still has everything someone breaking it open would expect it to have.
+        // There's no reasonable way to provide a selection UI and option on destruction, since it's an instant event
+        // that might not even have a player nearby, so random is the best they get.
+        OnSelectionMade(ent, _random.Pick(ent.Comp.Selections));
+    }
+
+    private void OnSelectionMade(Entity<EntityTableContainerSelectionComponent> ent,
+        ContainerSelectionEntry selection)
+    {
+        if (TerminatingOrDeleted(ent) || !Exists(ent))
+            return;
+
+        // This selection component has already delivered its goods, bail.
+        if (ent.Comp.SelectionMade)
+            return;
+
+        if (!TryComp(ent, out ContainerManagerComponent? containerComp))
+            return;
+
+        var xform = Transform(ent);
+        var coords = new EntityCoordinates(ent, Vector2.Zero);
+
+        foreach (var (containerId, table) in selection.Containers)
+        {
+            SpawnTableInTarget(ent, containerComp, xform, containerId, table, coords);
+        }
+
+        // Close the UI, mark the selection as made, and let all the clients know so they stop updating the UI.
+        _uiSystem.CloseUi(ent.Owner, ContainerSelectionUiKey.Key);
+        ent.Comp.SelectionMade = true;
+        Dirty(ent, ent.Comp);
+    }
+
+    private void SpawnTableInTarget(EntityUid target,
+        ContainerManagerComponent containerComp,
+        TransformComponent xform,
+        string containerId,
+        EntityTableSelector table,
+        EntityCoordinates coords)
+    {
+        // Does our target container actually exist?
+        if (!_containers.TryGetContainer(target, containerId, out var container, containerComp))
+        {
+            Log.Error(
+                $"Entity {ToPrettyString(target)} with a {nameof(EntityTableContainerSelectionComponent)} is missing a container ({containerId}).");
+            return;
+        }
+
+        // Get the contents we're filling with.
+        var spawns = _entityTable.GetSpawns(table);
+        foreach (var proto in spawns)
+        {
+            // Spawn the entity, try inserting it into the container, if we can't, log an error so someone knows
+            // their entity prototype is overfull and drop it on the ground instead.
+            var spawn = Spawn(proto, coords);
+            if (!_containers.Insert(spawn, container, containerXform: xform))
+            {
+                var alreadyContained = container.ContainedEntities.Count > 0
+                    ? string.Join("\n", container.ContainedEntities.Select(e => $"\t - {ToPrettyString(e)}"))
+                    : "< empty >";
+                Log.Error(
+                    $"Entity {ToPrettyString(target)} with a {nameof(EntityTableContainerSelectionComponent)} failed to insert an entity: {ToPrettyString(spawn)}.\nCurrent contents:\n{alreadyContained}");
+                _transform.AttachToGridOrMap(spawn);
+                break;
+            }
+        }
+    }
+}
diff --git a/Content.Shared/EntityTable/EntitySelectors/EntSelector.cs b/Content.Shared/EntityTable/EntitySelectors/EntSelector.cs
index ee2b0951d0..e6ae6579ff 100644
--- a/Content.Shared/EntityTable/EntitySelectors/EntSelector.cs
+++ b/Content.Shared/EntityTable/EntitySelectors/EntSelector.cs
@@ -30,7 +30,12 @@ protected override IEnumerable<EntProtoId> GetSpawnsImplementation(System.Random
 
     protected override IEnumerable<(EntProtoId spawn, double)> ListSpawnsImplementation(IEntityManager entMan, IPrototypeManager proto, EntityTableContext ctx)
     {
-        yield return (Id, 1f);
+        // DEN: Return an accurate count.
+        var num = Amount.Maximum();
+        for (var i = 0; i < num; i++)
+        {
+            yield return (Id, 1f);
+        }
     }
 
     protected override IEnumerable<(EntProtoId spawn, double)> AverageSpawnsImplementation(IEntityManager entMan, IPrototypeManager proto, EntityTableContext ctx)
diff --git a/Content.Shared/EntityTable/ValueSelector/BinomialNumberSelector.cs b/Content.Shared/EntityTable/ValueSelector/BinomialNumberSelector.cs
index c05d3bfa31..97c5b48075 100644
--- a/Content.Shared/EntityTable/ValueSelector/BinomialNumberSelector.cs
+++ b/Content.Shared/EntityTable/ValueSelector/BinomialNumberSelector.cs
@@ -51,4 +51,10 @@ public override float Average()
 
         return Trials * Chance;
     }
+
+    // DEN: Maximum allows for accurate ListSpawns
+    public override float Maximum()
+    {
+        return Trials;
+    }
 }
diff --git a/Content.Shared/EntityTable/ValueSelector/ConstantNumberSelector.cs b/Content.Shared/EntityTable/ValueSelector/ConstantNumberSelector.cs
index 30c664ac40..2e0a8b7e50 100644
--- a/Content.Shared/EntityTable/ValueSelector/ConstantNumberSelector.cs
+++ b/Content.Shared/EntityTable/ValueSelector/ConstantNumberSelector.cs
@@ -28,4 +28,10 @@ public override float Average()
     {
         return Value;
     }
+
+    // DEN: Used for accurate ListSpawns
+    public override float Maximum()
+    {
+        return Value;
+    }
 }
diff --git a/Content.Shared/EntityTable/ValueSelector/NumberSelector.cs b/Content.Shared/EntityTable/ValueSelector/NumberSelector.cs
index f4e3e7b286..50cb747a63 100644
--- a/Content.Shared/EntityTable/ValueSelector/NumberSelector.cs
+++ b/Content.Shared/EntityTable/ValueSelector/NumberSelector.cs
@@ -22,4 +22,11 @@ public abstract partial class NumberSelector
     /// </summary>
     /// <returns>The average amount of occurrences</returns>
     public abstract float Average();
+
+    // DEN: Used for accurate ListSpawns results
+    /// <summary>
+    /// Maximum number of occurrences
+    /// </summary>
+    /// <returns>The maximum number of occurrences</returns>
+    public abstract float Maximum();
 }
diff --git a/Content.Shared/EntityTable/ValueSelector/RangeNumberSelector.cs b/Content.Shared/EntityTable/ValueSelector/RangeNumberSelector.cs
index 0e82a2a378..02b3325b31 100644
--- a/Content.Shared/EntityTable/ValueSelector/RangeNumberSelector.cs
+++ b/Content.Shared/EntityTable/ValueSelector/RangeNumberSelector.cs
@@ -29,4 +29,10 @@ public override float Average()
     {
         return (Range.X + Range.Y) / 2f;
     }
+
+    // DEN: For accurate ListSpawns results.
+    public override float Maximum()
+    {
+        return Range.Y;
+    }
 }
diff --git a/Content.Shared/UserInterface/ActivatableUISystem.cs b/Content.Shared/UserInterface/ActivatableUISystem.cs
index 8b2299ccfc..1ba7bf777c 100644
--- a/Content.Shared/UserInterface/ActivatableUISystem.cs
+++ b/Content.Shared/UserInterface/ActivatableUISystem.cs
@@ -7,6 +7,7 @@
 using Content.Shared.Interaction;
 using Content.Shared.Interaction.Events;
 using Content.Shared.Popups;
+using Content.Shared.Storage.EntitySystems;
 using Content.Shared.Verbs;
 using Content.Shared.Whitelist;
 using Robust.Shared.Utility;
@@ -27,9 +28,9 @@ public override void Initialize()
         base.Initialize();
 
         SubscribeLocalEvent<ActivatableUIComponent, ComponentStartup>(OnStartup);
-        SubscribeLocalEvent<ActivatableUIComponent, UseInHandEvent>(OnUseInHand);
-        SubscribeLocalEvent<ActivatableUIComponent, ActivateInWorldEvent>(OnActivate);
-        SubscribeLocalEvent<ActivatableUIComponent, InteractUsingEvent>(OnInteractUsing);
+        SubscribeLocalEvent<ActivatableUIComponent, UseInHandEvent>(OnUseInHand, before: [typeof(SharedEntityStorageSystem), typeof(SharedStorageSystem)]); // DEN: Activatable UI before Inventory interactions
+        SubscribeLocalEvent<ActivatableUIComponent, ActivateInWorldEvent>(OnActivate, before: [typeof(SharedEntityStorageSystem), typeof(SharedStorageSystem)]); // DEN: Activatable UI before Inventory interactions
+        SubscribeLocalEvent<ActivatableUIComponent, InteractUsingEvent>(OnInteractUsing, before: [typeof(SharedEntityStorageSystem), typeof(SharedStorageSystem)]); // DEN: Activatable UI before Inventory interactions
         SubscribeLocalEvent<ActivatableUIComponent, HandDeselectedEvent>(OnHandDeselected);
         SubscribeLocalEvent<ActivatableUIComponent, GotUnequippedHandEvent>(OnHandUnequipped);
         SubscribeLocalEvent<ActivatableUIComponent, BoundUIClosedEvent>(OnUIClose);
diff --git a/Content.Shared/_DEN/Containers/Components/EntityTableContainerSelectionComponent.cs b/Content.Shared/_DEN/Containers/Components/EntityTableContainerSelectionComponent.cs
new file mode 100644
index 0000000000..49a5a0e8c7
--- /dev/null
+++ b/Content.Shared/_DEN/Containers/Components/EntityTableContainerSelectionComponent.cs
@@ -0,0 +1,42 @@
+using Content.Shared._DEN.Containers.EntitySystems;
+using Content.Shared.EntityTable.EntitySelectors;
+using Robust.Shared.GameStates;
+
+namespace Content.Shared._DEN.Containers.Components;
+
+/// <summary>
+///     Allows a container to be filled based on a selection that is provided to the user. Interactions will open
+///     the selection UI instead of opening the container until a selection is made. Once a selection is made the
+///     component effectively disables itself (it can't remove itself because the associated UI cannot be removed) and
+///     the container will function as normal.
+/// </summary>
+[RegisterComponent, NetworkedComponent, AutoGenerateComponentState, Access(typeof(SharedContainerSelectionSystem))]
+public sealed partial class EntityTableContainerSelectionComponent : Component
+{
+    // Whether a selection has already been made.
+    [AutoNetworkedField, ViewVariables]
+    public bool SelectionMade = false;
+
+    /// <summary>
+    ///     The list of possible selections for this Selection Component.
+    /// </summary>
+    [DataField]
+    public List<ContainerSelectionEntry> Selections = new();
+}
+
+[DataDefinition]
+public sealed partial class ContainerSelectionEntry
+{
+    /// <summary>
+    ///     The name of this selection group, this is a localization string and the result will be shown to users.
+    /// </summary>
+    [DataField("name")]
+    public LocId SelectionName;
+
+    /// <summary>
+    ///     Maps container names to <see cref="EntityTableSelector"/>. These will be used to populate the container
+    ///     once a selection is made.
+    /// </summary>
+    [DataField]
+    public Dictionary<string, EntityTableSelector> Containers = new();
+}
diff --git a/Content.Shared/_DEN/Containers/EntitySystems/SharedContainerSelectionSystem.cs b/Content.Shared/_DEN/Containers/EntitySystems/SharedContainerSelectionSystem.cs
new file mode 100644
index 0000000000..e05bc15838
--- /dev/null
+++ b/Content.Shared/_DEN/Containers/EntitySystems/SharedContainerSelectionSystem.cs
@@ -0,0 +1,21 @@
+using Content.Shared._DEN.Containers.Components;
+using Content.Shared.UserInterface;
+
+namespace Content.Shared._DEN.Containers.EntitySystems;
+
+public abstract partial class SharedContainerSelectionSystem : EntitySystem
+{
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<EntityTableContainerSelectionComponent, ActivatableUIOpenAttemptEvent>(
+            OnUserOpenUIAttempt);
+    }
+
+    private void OnUserOpenUIAttempt(Entity<EntityTableContainerSelectionComponent> ent, ref ActivatableUIOpenAttemptEvent args)
+    {
+        if (ent.Comp.SelectionMade)
+            args.Cancel();
+    }
+}
diff --git a/Content.Shared/_DEN/Containers/Events/ContainerSelectionEvents.cs b/Content.Shared/_DEN/Containers/Events/ContainerSelectionEvents.cs
new file mode 100644
index 0000000000..07ca3da9ee
--- /dev/null
+++ b/Content.Shared/_DEN/Containers/Events/ContainerSelectionEvents.cs
@@ -0,0 +1,19 @@
+using Robust.Shared.Serialization;
+
+namespace Content.Shared._DEN.Containers.Events;
+
+/// <summary>
+///     Sent client -> server to tell the server we're trying to make a selection on an inventory.
+/// </summary>
+/// <param name="selectionIndex">The index in the selection list that the user selected.</param>
+[Serializable, NetSerializable]
+public sealed class ContainerSelectionMessage(int selectionIndex) : BoundUserInterfaceMessage
+{
+    public readonly int SelectionIndex = selectionIndex;
+}
+
+[Serializable, NetSerializable]
+public enum ContainerSelectionUiKey
+{
+    Key,
+}
diff --git a/Resources/Locale/en-US/_DEN/container-selection/container-selection.ftl b/Resources/Locale/en-US/_DEN/container-selection/container-selection.ftl
new file mode 100644
index 0000000000..cf92d44a14
--- /dev/null
+++ b/Resources/Locale/en-US/_DEN/container-selection/container-selection.ftl
@@ -0,0 +1,6 @@
+container-selection-ui-title = Select Container Contents
+container-selection-ui-choose-button = Choose
+container-selection-ui-contents = Contains:
+
+container-selection-group-crowbars = Crowbars
+container-selection-group-plushies = Plushies
diff --git a/Resources/Prototypes/_DEN/Entities/Objects/Misc/container_selection.yml b/Resources/Prototypes/_DEN/Entities/Objects/Misc/container_selection.yml
new file mode 100644
index 0000000000..08b86c322f
--- /dev/null
+++ b/Resources/Prototypes/_DEN/Entities/Objects/Misc/container_selection.yml
@@ -0,0 +1,10 @@
+- type: entity
+  abstract: true
+  id: ContainerSelectionBase
+  components:
+  - type: ActivatableUI
+    key: enum.ContainerSelectionUiKey.Key
+  - type: UserInterface
+    interfaces:
+      enum.ContainerSelectionUiKey.Key:
+        type: ContainerSelectionBoundUserInterface
diff --git a/Resources/Prototypes/_DEN/Entities/Structures/Storage/Closets/Lockers/lockers.yml b/Resources/Prototypes/_DEN/Entities/Structures/Storage/Closets/Lockers/lockers.yml
new file mode 100644
index 0000000000..6c84161f65
--- /dev/null
+++ b/Resources/Prototypes/_DEN/Entities/Structures/Storage/Closets/Lockers/lockers.yml
@@ -0,0 +1,24 @@
+- type: entity
+  parent: [ LockerBaseSecure, ContainerSelectionBase ]
+  id: ContainerSelectionLockerDebug
+  name: container selection locker debug
+  description: A debug locker for testing container selection
+  suffix: DEBUG
+  categories: [ Debug, DoNotMap ]
+  components:
+  - type: EntityTableContainerSelection
+    selections:
+      - name: container-selection-group-crowbars
+        containers:
+          entity_storage: !type:AllSelector
+            children:
+            - id: Crowbar
+              amount: 12
+      - name: container-selection-group-plushies
+        containers:
+          entity_storage: !type:AllSelector
+            children:
+            - id: PlushieRGBee
+            - id: PlushieLizard
+            - id: PlushieMoth
+            - id: PlushieVulp