diff --git a/Content.Client/Medical/Cryogenics/BeakerBarChart.cs b/Content.Client/Medical/Cryogenics/BeakerBarChart.cs
new file mode 100644
index 00000000000..25301b52686
--- /dev/null
+++ b/Content.Client/Medical/Cryogenics/BeakerBarChart.cs
@@ -0,0 +1,285 @@
+using System.Diagnostics.CodeAnalysis;
+using System.Numerics;
+using Robust.Client.Graphics;
+using Robust.Client.UserInterface;
+using Robust.Client.UserInterface.Controls;
+using Robust.Client.UserInterface.CustomControls;
+using Robust.Shared.Timing;
+using Robust.Shared.Utility;
+
+// ReSharper disable CompareOfFloatsByEqualityOperator
+
+namespace Content.Client.Medical.Cryogenics;
+
+
+public sealed class BeakerBarChart : Control
+{
+    private sealed class Entry
+    {
+        public float WidthFraction;  // This entry's width as a fraction of the chart's total width (between 0 and 1)
+        public float TargetAmount;
+        public string Uid; // This UID is used to track entries between frames, for animation.
+        public string? Tooltip;
+        public Color Color;
+        public Label Label;
+
+        public Entry(string uid, Label label)
+        {
+            Uid = uid;
+            Label = label;
+        }
+    }
+
+    public float Capacity = 50;
+
+    public Color NotchColor = new(1, 1, 1, 0.25f);
+    public Color BackgroundColor = new(0.1f, 0.1f, 0.1f);
+
+    public int MediumNotchInterval = 5;
+    public int BigNotchInterval = 10;
+
+    // When we have a very large beaker (i.e. bluespace beaker) we might need to increase the distance between notches.
+    // The distance between notches is increased by ScaleMultiplier when the distance between notches is less than
+    // MinSmallNotchScreenDistance in UI units.
+    public int MinSmallNotchScreenDistance = 2;
+    public int ScaleMultiplier = 10;
+
+    public float SmallNotchHeight = 0.1f;
+    public float MediumNotchHeight = 0.25f;
+    public float BigNotchHeight = 1f;
+
+    // We don't animate new entries until this control has been drawn at least once.
+    private bool _hasBeenDrawn = false;
+
+    // This is used to keep the segments of the chart in the same order as the SetEntry calls.
+    // For example: In update 1 we might get cryox, alox, bic (in that order), and in update 2 we get alox, cryox, bic.
+    // To keep the order of the entries the same as the order of the SetEntry calls, we let the old cryox entry
+    // disappear and create a new cryox entry behind the alox entry.
+    private int _nextUpdateableEntry = 0;
+
+    private readonly List<Entry> _entries = new();
+
+
+    public BeakerBarChart()
+    {
+        MouseFilter = MouseFilterMode.Pass;
+        TooltipSupplier = SupplyTooltip;
+    }
+
+    public void Clear()
+    {
+        foreach (var entry in _entries)
+        {
+            entry.TargetAmount = 0;
+        }
+
+        _nextUpdateableEntry = 0;
+    }
+
+    /// <summary>
+    /// Either adds a new entry to the chart if the UID doesn't appear yet, or updates the amount of an existing entry.
+    /// </summary>
+    public void SetEntry(
+        string uid,
+        string label,
+        float amount,
+        Color color,
+        Color? textColor = null,
+        string? tooltip = null)
+    {
+        // If we can find an old entry we're allowed to update, update that one.
+        if (TryFindUpdateableEntry(uid, out var index))
+        {
+            _entries[index].TargetAmount = amount;
+            _entries[index].Tooltip = tooltip;
+            _entries[index].Label.Text = label;
+            _nextUpdateableEntry = index + 1;
+            return;
+        }
+
+        // Otherwise create a new entry.
+        if (amount <= 0)
+            return;
+
+        // If no text color is provided, use either white or black depending on how dark the background is.
+        textColor ??= (color.R + color.G + color.B < 1.5f ? Color.White : Color.Black);
+
+        var childLabel = new Label
+        {
+            Text = label,
+            ClipText = true,
+            FontColorOverride = textColor,
+            Margin = new Thickness(4, 0, 0, 0)
+        };
+        AddChild(childLabel);
+
+        _entries.Insert(
+            _nextUpdateableEntry,
+            new Entry(uid, childLabel)
+            {
+                WidthFraction = (_hasBeenDrawn ? 0 : amount / Capacity),
+                TargetAmount = amount,
+                Tooltip = tooltip,
+                Color = color
+            }
+        );
+
+        _nextUpdateableEntry += 1;
+    }
+
+    private bool TryFindUpdateableEntry(string uid, out int index)
+    {
+        for (int i = _nextUpdateableEntry; i < _entries.Count; i++)
+        {
+            if (_entries[i].Uid == uid)
+            {
+                index = i;
+                return true;
+            }
+        }
+
+        index = -1;
+        return false;
+    }
+
+    private IEnumerable<(Entry, float xMin, float xMax)> EntryRanges(float? pixelWidth = null)
+    {
+        float chartWidth = pixelWidth ?? PixelWidth;
+        var xStart = 0f;
+
+        foreach (var entry in _entries)
+        {
+            var entryWidth = entry.WidthFraction * chartWidth;
+            var xEnd = MathF.Min(xStart + entryWidth, chartWidth);
+
+            yield return (entry, xStart, xEnd);
+
+            xStart = xEnd;
+        }
+    }
+
+    private bool TryFindEntry(float x, [NotNullWhen(true)] out Entry? entry)
+    {
+        foreach (var (currentEntry, xMin, xMax) in EntryRanges())
+        {
+            if (xMin <= x && x < xMax)
+            {
+                entry = currentEntry;
+                return true;
+            }
+        }
+
+        entry = null;
+        return false;
+    }
+
+    protected override void FrameUpdate(FrameEventArgs args)
+    {
+        // Tween the amounts to their target amounts.
+        const float tweenInverseHalfLife = 8;  // Half life of tween is 1/n
+        var hasChanged = false;
+
+        foreach (var entry in _entries)
+        {
+            var targetWidthFraction = entry.TargetAmount / Capacity;
+
+            if (entry.WidthFraction == targetWidthFraction)
+                continue;
+
+            // Tween with lerp abuse interpolation
+            entry.WidthFraction = MathHelper.Lerp(
+                entry.WidthFraction,
+                targetWidthFraction,
+                MathHelper.Clamp01(tweenInverseHalfLife * args.DeltaSeconds)
+            );
+            hasChanged = true;
+
+            if (MathF.Abs(entry.WidthFraction - targetWidthFraction) < 0.0001f)
+                entry.WidthFraction = targetWidthFraction;
+        }
+
+        if (!hasChanged)
+            return;
+
+        InvalidateArrange();
+
+        // Remove old entries whose animations have finished.
+        foreach (var entry in _entries)
+        {
+            if (entry.WidthFraction == 0 && entry.TargetAmount == 0)
+                RemoveChild(entry.Label);
+        }
+
+        _entries.RemoveAll(entry => entry.WidthFraction == 0 && entry.TargetAmount == 0);
+    }
+
+    protected override void MouseMove(GUIMouseMoveEventArgs args)
+    {
+        HideTooltip();
+    }
+
+    protected override void Draw(DrawingHandleScreen handle)
+    {
+        handle.DrawRect(PixelSizeBox, BackgroundColor);
+
+        // Draw the entry backgrounds
+        foreach (var (entry, xMin, xMax) in EntryRanges())
+        {
+            if (xMin != xMax)
+                handle.DrawRect(new(xMin, 0, xMax, PixelHeight), entry.Color);
+        }
+
+        // Draw notches
+        var unitWidth = PixelWidth / Capacity;
+        var unitsPerNotch = 1;
+
+        while (unitWidth < MinSmallNotchScreenDistance)
+        {
+            // This is here for 1000u bluespace beakers. If the distance between small notches is so small that it would
+            // be very ugly, we reduce the amount of notches by ScaleMultiplier (currently a factor of 10).
+            // (I could use an analytical algorithm here, but it would be more difficult to read with pretty much no
+            //  performance benefit, since it loops zero times normally and one time for the bluespace beaker)
+            unitWidth *= ScaleMultiplier;
+            unitsPerNotch *= ScaleMultiplier;
+        }
+
+        for (int i = 0; i <= Capacity / unitsPerNotch; i++)
+        {
+            var x = i * unitWidth;
+            var height = (i % BigNotchInterval    == 0 ? BigNotchHeight :
+                          i % MediumNotchInterval == 0 ? MediumNotchHeight :
+                                                         SmallNotchHeight) * PixelHeight;
+            var start = new Vector2(x, PixelHeight);
+            var end = new Vector2(x, PixelHeight - height);
+            handle.DrawLine(start, end, NotchColor);
+        }
+
+        _hasBeenDrawn = true;
+    }
+
+    protected override Vector2 ArrangeOverride(Vector2 finalSize)
+    {
+        foreach (var (entry, xMin, xMax) in EntryRanges(finalSize.X))
+        {
+            entry.Label.Arrange(new((int)xMin, 0, (int)xMax, (int)finalSize.Y));
+        }
+
+        return finalSize;
+    }
+
+    private Control? SupplyTooltip(Control sender)
+    {
+        var globalMousePos = UserInterfaceManager.MousePositionScaled.Position;
+        var mousePos = globalMousePos - GlobalPosition;
+
+        if (!TryFindEntry(mousePos.X, out var entry) || entry.Tooltip == null)
+            return null;
+
+        var msg = new FormattedMessage();
+        msg.AddText(entry.Tooltip);
+
+        var tooltip = new Tooltip();
+        tooltip.SetMessage(msg);
+        return tooltip;
+    }
+}
diff --git a/Content.Client/_Starlight/Plumbing/PlumbingConnectorAppearanceSystem.cs b/Content.Client/_Starlight/Plumbing/PlumbingConnectorAppearanceSystem.cs
new file mode 100644
index 00000000000..a165bdab176
--- /dev/null
+++ b/Content.Client/_Starlight/Plumbing/PlumbingConnectorAppearanceSystem.cs
@@ -0,0 +1,184 @@
+using System.Numerics;
+using Content.Shared._Starlight.Plumbing;
+using Content.Shared._Starlight.Plumbing.Components;
+using Content.Client.SubFloor;
+using Content.Shared.Atmos;
+using Content.Shared.Atmos.Piping;
+using JetBrains.Annotations;
+using Robust.Client.GameObjects;
+
+namespace Content.Client._Starlight.Plumbing;
+
+/// <summary>
+///     Client system that creates and updates plumbing connector sprite layers.
+///     Single layer per direction that switches between disconnected/connected sprites
+///     Layers hide when covered by floor tiles (server sends CoveredByFloor state)
+/// </summary>
+[UsedImplicitly]
+public sealed class PlumbingConnectorAppearanceSystem : EntitySystem
+{
+    [Dependency] private readonly SharedAppearanceSystem _appearance = default!;
+    [Dependency] private readonly SpriteSystem _sprite = default!;
+
+    private static readonly Color InletColor = new(1.0f, 0.35f, 0.35f);  // Vibrant Red
+    private static readonly Color OutletColor = new(0.35f, 0.6f, 1.0f);  // Vibrant Blue
+    private static readonly Color MixingInletColor = new(0.35f, 0.9f, 0.35f);  // Vibrant Green
+    private static readonly PlumbingConnectionLayer[] ConnectionLayers = Enum.GetValues<PlumbingConnectionLayer>();
+
+    private EntityQuery<TransformComponent> _xformQuery;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+        _xformQuery = GetEntityQuery<TransformComponent>();
+
+        SubscribeLocalEvent<PlumbingConnectorAppearanceComponent, ComponentInit>(OnInit);
+        SubscribeLocalEvent<PlumbingConnectorAppearanceComponent, AppearanceChangeEvent>(OnAppearanceChanged, after: [typeof(SubFloorHideSystem)]);
+    }
+
+    private void OnInit(EntityUid uid, PlumbingConnectorAppearanceComponent component, ComponentInit args)
+    {
+        if (!TryComp(uid, out SpriteComponent? sprite))
+            return;
+
+        // Create one layer for each cardinal direction
+        // The layer will swap between disconnected/connected sprites based on connection state
+        // Insert at layer 0 so connectors render UNDER the plumbing machine sprite
+        foreach (var layerKey in ConnectionLayers)
+        {
+            var offset = GetDirectionOffset(layerKey, component.Offset);
+
+            // Each insertion at 0 pushes previous layers up, so we use index 0 for all operations
+            var layerName = layerKey.ToString();
+            _sprite.AddBlankLayer((uid, sprite), 0);
+            _sprite.LayerMapSet((uid, sprite), layerName, 0);
+
+            // Disconnected connectors are offset from center to show under big machine sprites. 
+            _sprite.LayerSetRsi((uid, sprite), 0, component.Disconnected.RsiPath);
+            _sprite.LayerSetRsiState((uid, sprite), 0, component.Disconnected.RsiState);
+            _sprite.LayerSetDirOffset((uid, sprite), 0, ToOffset(layerKey));
+            _sprite.LayerSetVisible((uid, sprite), 0, false);
+            if (offset != Vector2.Zero)
+                _sprite.LayerSetOffset((uid, sprite), 0, offset);
+        }
+    }
+
+    private static Vector2 GetDirectionOffset(PlumbingConnectionLayer layer, float offset)
+    {
+        return ((PipeDirection)layer).ToDirection().ToVec() * offset;
+    }
+
+    private void OnAppearanceChanged(EntityUid uid, PlumbingConnectorAppearanceComponent component, ref AppearanceChangeEvent args)
+    {
+        if (args.Sprite == null)
+            return;
+
+        if (!args.Sprite.Visible)
+        {
+            return;
+        }
+
+        // Hide if no nodes exists somehow
+        if (!_appearance.TryGetData<int>(uid, PlumbingVisuals.NodeDirections, out var nodeDirectionsInt, args.Component))
+        {
+            HideAllLayers(uid, args.Sprite);
+            return;
+        }
+
+        if (!_appearance.TryGetData<int>(uid, PlumbingVisuals.ConnectedDirections, out var connectedDirectionsInt, args.Component))
+            connectedDirectionsInt = 0;
+
+        if (!_appearance.TryGetData<int>(uid, PlumbingVisuals.InletDirections, out var inletDirectionsInt, args.Component))
+            inletDirectionsInt = 0;
+        if (!_appearance.TryGetData<int>(uid, PlumbingVisuals.OutletDirections, out var outletDirectionsInt, args.Component))
+            outletDirectionsInt = 0;
+        if (!_appearance.TryGetData<int>(uid, PlumbingVisuals.MixingInletDirections, out var mixingInletDirectionsInt, args.Component))
+            mixingInletDirectionsInt = 0;
+
+        if (!_appearance.TryGetData<bool>(uid, PlumbingVisuals.CoveredByFloor, out var coveredByFloor, args.Component))
+            coveredByFloor = false;
+
+        var nodeDirections = (PipeDirection)nodeDirectionsInt;
+        var connectedDirections = (PipeDirection)connectedDirectionsInt;
+        var inletDirections = (PipeDirection)inletDirectionsInt;
+        var outletDirections = (PipeDirection)outletDirectionsInt;
+        var mixingInletDirections = (PipeDirection)mixingInletDirectionsInt;
+
+        // Get the entity's local rotation to transform world directions to local
+        if (!_xformQuery.TryGetComponent(uid, out var xform))
+            return;
+        var localRotation = xform.LocalRotation;
+        var connectedDirectionsLocal = connectedDirections.RotatePipeDirection(-localRotation);
+        var nodeDirectionsLocal = nodeDirections.RotatePipeDirection(-localRotation);
+        var inletDirectionsLocal = inletDirections.RotatePipeDirection(-localRotation);
+        var outletDirectionsLocal = outletDirections.RotatePipeDirection(-localRotation);
+        var mixingInletDirectionsLocal = mixingInletDirections.RotatePipeDirection(-localRotation);
+
+
+        foreach (var layerKey in ConnectionLayers)
+        {
+            var dir = (PipeDirection)layerKey;
+            var hasNode = nodeDirectionsLocal.HasDirection(dir);
+            var isConnected = connectedDirectionsLocal.HasDirection(dir);
+            var isInlet = inletDirectionsLocal.HasDirection(dir);
+            var isOutlet = outletDirectionsLocal.HasDirection(dir);
+            var isMixingInlet = mixingInletDirectionsLocal.HasDirection(dir);
+
+            // Determine color based on inlet/outlet/mixing
+            var color = isMixingInlet ? MixingInletColor : isInlet ? InletColor : isOutlet ? OutletColor : Color.White;
+
+            var layerName = layerKey.ToString();
+            if (_sprite.LayerMapTryGet((uid, args.Sprite), layerName, out var layerKey2, false))
+            {
+                var layer = args.Sprite[layerKey2];
+                layer.Visible = hasNode && !coveredByFloor;
+                
+                if (layer.Visible)
+                {
+                    // Swap sprite based on connection state
+                    if (isConnected)
+                    {
+                        _sprite.LayerSetRsiState((uid, args.Sprite), layerKey2, component.Connected.RsiState);
+                        _sprite.LayerSetOffset((uid, args.Sprite), layerKey2, Vector2.Zero);
+                    }
+                    else
+                    {
+                        _sprite.LayerSetRsiState((uid, args.Sprite), layerKey2, component.Disconnected.RsiState);
+                        _sprite.LayerSetOffset((uid, args.Sprite), layerKey2, GetDirectionOffset(layerKey, component.Offset));
+                    }
+                    layer.Color = color;
+                }
+            }
+        }
+    }
+
+    private void HideAllLayers(EntityUid uid, SpriteComponent sprite)
+    {
+        foreach (var layerKey in ConnectionLayers)
+        {
+            var layerName = layerKey.ToString();
+            if (_sprite.LayerMapTryGet((uid, sprite), layerName, out var key, false))
+                sprite[key].Visible = false;
+        }
+    }
+
+
+    private SpriteComponent.DirectionOffset ToOffset(PlumbingConnectionLayer layer)
+    {
+        return layer switch
+        {
+            PlumbingConnectionLayer.NorthConnection => SpriteComponent.DirectionOffset.Flip,
+            PlumbingConnectionLayer.EastConnection => SpriteComponent.DirectionOffset.CounterClockwise,
+            PlumbingConnectionLayer.WestConnection => SpriteComponent.DirectionOffset.Clockwise,
+            _ => SpriteComponent.DirectionOffset.None, // SouthConnection
+        };
+    }
+
+    private enum PlumbingConnectionLayer : byte
+    {
+        NorthConnection = PipeDirection.North,
+        SouthConnection = PipeDirection.South,
+        EastConnection = PipeDirection.East,
+        WestConnection = PipeDirection.West,
+    }
+}
diff --git a/Content.Client/_Starlight/Plumbing/UI/PlumbingFilterBoundUserInterface.cs b/Content.Client/_Starlight/Plumbing/UI/PlumbingFilterBoundUserInterface.cs
new file mode 100644
index 00000000000..c35ca54913a
--- /dev/null
+++ b/Content.Client/_Starlight/Plumbing/UI/PlumbingFilterBoundUserInterface.cs
@@ -0,0 +1,57 @@
+using Content.Shared._Starlight.Plumbing;
+using JetBrains.Annotations;
+using Robust.Client.UserInterface;
+
+namespace Content.Client._Starlight.Plumbing.UI;
+
+[UsedImplicitly]
+public sealed class PlumbingFilterBoundUserInterface : BoundUserInterface
+{
+    private PlumbingFilterWindow? _window;
+
+    public PlumbingFilterBoundUserInterface(EntityUid owner, Enum uiKey) : base(owner, uiKey)
+    {
+    }
+
+    protected override void Open()
+    {
+        base.Open();
+
+        _window = this.CreateWindow<PlumbingFilterWindow>();
+
+        _window.OnToggle += OnToggle;
+        _window.OnAddReagent += OnAddReagent;
+        _window.OnRemoveReagent += OnRemoveReagent;
+        _window.OnClear += OnClear;
+    }
+
+    private void OnToggle(bool enabled)
+    {
+        SendMessage(new PlumbingFilterToggleMessage(enabled));
+    }
+
+    private void OnAddReagent(string reagentId)
+    {
+        SendMessage(new PlumbingFilterAddReagentMessage(reagentId));
+    }
+
+    private void OnRemoveReagent(string reagentId)
+    {
+        SendMessage(new PlumbingFilterRemoveReagentMessage(reagentId));
+    }
+
+    private void OnClear()
+    {
+        SendMessage(new PlumbingFilterClearMessage());
+    }
+
+    protected override void UpdateState(BoundUserInterfaceState state)
+    {
+        base.UpdateState(state);
+
+        if (_window == null || state is not PlumbingFilterBoundUserInterfaceState cast)
+            return;
+
+        _window.UpdateState(cast);
+    }
+}
diff --git a/Content.Client/_Starlight/Plumbing/UI/PlumbingFilterWindow.xaml b/Content.Client/_Starlight/Plumbing/UI/PlumbingFilterWindow.xaml
new file mode 100644
index 00000000000..9a47109fde3
--- /dev/null
+++ b/Content.Client/_Starlight/Plumbing/UI/PlumbingFilterWindow.xaml
@@ -0,0 +1,29 @@
+<DefaultWindow xmlns="https://spacestation14.io"
+               xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+               MinSize="350 300" Title="{Loc plumbing-filter-window-title}">
+    <BoxContainer Orientation="Vertical" Margin="5 5 5 5" SeparationOverride="8">
+        <!-- Status toggle -->
+        <BoxContainer Orientation="Horizontal" HorizontalExpand="True">
+            <Label Text="{Loc plumbing-filter-status}" />
+            <Button Name="ToggleStatusButton" MinWidth="80" />
+        </BoxContainer>
+
+        <!-- Add reagent section -->
+        <PanelContainer StyleClasses="LowDivider" />
+        <Label Text="{Loc plumbing-filter-add-reagent}" StyleClasses="LabelHeading" />
+        <BoxContainer Orientation="Horizontal" HorizontalExpand="True" SeparationOverride="5">
+            <LineEdit Name="ReagentIdInput" PlaceHolder="{Loc plumbing-filter-reagent-id}" HorizontalExpand="True" />
+            <Button Name="AddReagentButton" Text="{Loc plumbing-filter-add}" MinWidth="50" />
+        </BoxContainer>
+        <ItemList Name="SuggestionList" SelectMode="Single" MinHeight="80" MaxHeight="120" HorizontalExpand="True" Visible="False" />
+
+        <!-- Filtered reagents list -->
+        <PanelContainer StyleClasses="LowDivider" />
+        <BoxContainer Orientation="Horizontal">
+            <Label Text="{Loc plumbing-filter-filtered}" StyleClasses="LabelHeading" HorizontalExpand="True" />
+            <Button Name="ClearButton" Text="{Loc plumbing-filter-clear}" MinWidth="60" />
+        </BoxContainer>
+        <ItemList Name="FilteredList" SelectMode="Single" VerticalExpand="True" MinHeight="100" />
+        <Button Name="RemoveButton" Text="{Loc plumbing-filter-remove-selected}" Disabled="True" />
+    </BoxContainer>
+</DefaultWindow>
diff --git a/Content.Client/_Starlight/Plumbing/UI/PlumbingFilterWindow.xaml.cs b/Content.Client/_Starlight/Plumbing/UI/PlumbingFilterWindow.xaml.cs
new file mode 100644
index 00000000000..bf77656895c
--- /dev/null
+++ b/Content.Client/_Starlight/Plumbing/UI/PlumbingFilterWindow.xaml.cs
@@ -0,0 +1,143 @@
+using Content.Shared._Starlight.Plumbing;
+using Content.Shared.Chemistry.Reagent;
+using Robust.Client.AutoGenerated;
+using Robust.Client.UserInterface.Controls;
+using Robust.Client.UserInterface.CustomControls;
+using Robust.Client.UserInterface.XAML;
+using Robust.Shared.IoC;
+using Robust.Shared.Localization;
+using Robust.Shared.Prototypes;
+
+namespace Content.Client._Starlight.Plumbing.UI;
+
+[GenerateTypedNameReferences]
+public sealed partial class PlumbingFilterWindow : DefaultWindow
+{
+    [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
+
+    public event Action<bool>? OnToggle;
+    public event Action<string>? OnAddReagent;
+    public event Action<string>? OnRemoveReagent;
+    public event Action? OnClear;
+
+    private bool _enabled = true;
+    private string? _selectedReagent;
+
+    public PlumbingFilterWindow()
+    {
+        IoCManager.InjectDependencies(this);
+        RobustXamlLoader.Load(this);
+
+        ToggleStatusButton.OnPressed += _ =>
+        {
+            _enabled = !_enabled;
+            UpdateToggleButton();
+            OnToggle?.Invoke(_enabled);
+        };
+
+        AddReagentButton.OnPressed += _ =>
+        {
+            var reagentId = ReagentIdInput.Text.Trim();
+            if (string.IsNullOrEmpty(reagentId))
+                return;
+
+            OnAddReagent?.Invoke(reagentId);
+            ReagentIdInput.Text = "";
+            SuggestionList.Visible = false;
+        };
+
+        ReagentIdInput.OnTextChanged += _ => UpdateSuggestions(ReagentIdInput.Text);
+
+        SuggestionList.OnItemSelected += args =>
+        {
+            var selected = args.ItemList[args.ItemIndex].Metadata as string;
+            if (selected != null)
+            {
+                ReagentIdInput.Text = selected;
+                SuggestionList.Visible = false;
+            }
+        };
+
+        RemoveButton.OnPressed += _ =>
+        {
+            if (_selectedReagent != null)
+                OnRemoveReagent?.Invoke(_selectedReagent);
+        };
+
+        ClearButton.OnPressed += _ => OnClear?.Invoke();
+
+        FilteredList.OnItemSelected += args =>
+        {
+            _selectedReagent = args.ItemList[args.ItemIndex].Metadata as string;
+            RemoveButton.Disabled = _selectedReagent == null;
+        };
+
+        FilteredList.OnItemDeselected += _ =>
+        {
+            _selectedReagent = null;
+            RemoveButton.Disabled = true;
+        };
+    }
+
+    private void UpdateToggleButton()
+    {
+        ToggleStatusButton.Text = _enabled
+            ? Loc.GetString("plumbing-filter-enabled")
+            : Loc.GetString("plumbing-filter-disabled");
+    }
+
+    public void UpdateState(PlumbingFilterBoundUserInterfaceState state)
+    {
+        _enabled = state.Enabled;
+        UpdateToggleButton();
+
+        FilteredList.Clear();
+        foreach (var reagentId in state.FilteredReagents)
+        {
+            FilteredList.Add(new ItemList.Item(FilteredList)
+            {
+                Metadata = reagentId,
+                Text = reagentId
+            });
+        }
+
+        _selectedReagent = null;
+        RemoveButton.Disabled = true;
+    }
+
+    private void UpdateSuggestions(string filter)
+    {
+        SuggestionList.Clear();
+
+        if (string.IsNullOrWhiteSpace(filter))
+        {
+            SuggestionList.Visible = false;
+            return;
+        }
+
+        var lowerFilter = filter.Trim().ToLowerInvariant();
+
+        var matches = new List<ReagentPrototype>();
+
+        foreach (var reagent in _prototypeManager.EnumeratePrototypes<ReagentPrototype>())
+        {
+            if (!reagent.ID.ToLowerInvariant().Contains(lowerFilter))
+                continue;
+
+            matches.Add(reagent);
+        }
+
+        matches.Sort((a, b) => a.ID.Length.CompareTo(b.ID.Length));
+
+        foreach (var reagent in matches)
+        {
+            SuggestionList.Add(new ItemList.Item(SuggestionList)
+            {
+                Metadata = reagent.ID,
+                Text = reagent.ID
+            });
+        }
+
+        SuggestionList.Visible = SuggestionList.Count > 0;
+    }
+}
diff --git a/Content.Client/_Starlight/Plumbing/UI/PlumbingPillPressBoundUserInterface.cs b/Content.Client/_Starlight/Plumbing/UI/PlumbingPillPressBoundUserInterface.cs
new file mode 100644
index 00000000000..3d377e0de0c
--- /dev/null
+++ b/Content.Client/_Starlight/Plumbing/UI/PlumbingPillPressBoundUserInterface.cs
@@ -0,0 +1,50 @@
+using Content.Shared._Starlight.Plumbing;
+using JetBrains.Annotations;
+using Robust.Client.UserInterface;
+
+namespace Content.Client._Starlight.Plumbing.UI;
+
+[UsedImplicitly]
+public sealed class PlumbingPillPressBoundUserInterface : BoundUserInterface
+{
+    private PlumbingPillPressWindow? _window;
+
+    public PlumbingPillPressBoundUserInterface(EntityUid owner, Enum uiKey) : base(owner, uiKey)
+    {
+    }
+
+    protected override void Open()
+    {
+        base.Open();
+
+        _window = this.CreateWindow<PlumbingPillPressWindow>();
+
+        _window.OnToggle += enabled =>
+            SendMessage(new PlumbingPillPressToggleMessage(enabled));
+
+        _window.OnSetDosage += dosage =>
+            SendMessage(new PlumbingPillPressSetDosageMessage(dosage));
+
+        _window.OnSetOutputMode += mode =>
+            SendMessage(new PlumbingPillPressSetOutputModeMessage(mode));
+
+        _window.OnSetPillType += pillType =>
+            SendMessage(new PlumbingPillPressSetPillTypeMessage(pillType));
+
+        _window.OnSetMixing += mixingEnabled =>
+            SendMessage(new PlumbingPillPressSetMixingMessage(mixingEnabled));
+
+        _window.OnSetInletRatio += (inlet, ratio) =>
+            SendMessage(new PlumbingPillPressSetInletRatioMessage(inlet, ratio));
+    }
+
+    protected override void UpdateState(BoundUserInterfaceState state)
+    {
+        base.UpdateState(state);
+
+        if (_window == null || state is not PlumbingPillPressBoundUserInterfaceState cast)
+            return;
+
+        _window.UpdateState(cast);
+    }
+}
diff --git a/Content.Client/_Starlight/Plumbing/UI/PlumbingPillPressWindow.xaml b/Content.Client/_Starlight/Plumbing/UI/PlumbingPillPressWindow.xaml
new file mode 100644
index 00000000000..3f4e55b058f
--- /dev/null
+++ b/Content.Client/_Starlight/Plumbing/UI/PlumbingPillPressWindow.xaml
@@ -0,0 +1,61 @@
+<DefaultWindow xmlns="https://spacestation14.io"
+               xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+               MinSize="380 420"
+               Title="{Loc plumbing-pill-press-window-title}">
+    <BoxContainer Orientation="Vertical" Margin="5 5 5 5" SeparationOverride="8">
+        <!-- Status toggle -->
+        <BoxContainer Orientation="Horizontal" HorizontalExpand="True">
+            <Label Text="{Loc plumbing-pill-press-status}" />
+            <Button Name="ToggleStatusButton" MinWidth="80" />
+        </BoxContainer>
+
+        <PanelContainer StyleClasses="LowDivider" />
+
+        <!-- Output mode selector -->
+        <BoxContainer Orientation="Horizontal" HorizontalExpand="True">
+            <Label Text="{Loc plumbing-pill-press-output-mode}" />
+            <OptionButton Name="OutputModeSelector" MinWidth="100" HorizontalExpand="True" />
+        </BoxContainer>
+
+        <!-- Dosage input -->
+        <BoxContainer Orientation="Horizontal" HorizontalExpand="True">
+            <Label Text="{Loc plumbing-pill-press-dosage}" />
+            <LineEdit Name="DosageInput" PlaceHolder="10" MinWidth="60" HorizontalExpand="True" />
+            <Button Name="SetDosageButton" Text="{Loc plumbing-pill-press-set}" MinWidth="50" />
+        </BoxContainer>
+
+        <PanelContainer StyleClasses="LowDivider" />
+
+        <!-- Pill type selector (hidden for patches) -->
+        <BoxContainer Name="PillTypeContainer" Orientation="Vertical" SeparationOverride="4">
+            <Label Text="{Loc plumbing-pill-press-pill-type}" StyleClasses="LabelHeading" />
+            <GridContainer Name="PillTypeGrid" Columns="10" />
+        </BoxContainer>
+
+        <PanelContainer StyleClasses="LowDivider" />
+
+        <!-- Mixing mode section -->
+        <BoxContainer Orientation="Horizontal" HorizontalExpand="True">
+            <CheckBox Name="MixingToggle" />
+            <Label Text="{Loc plumbing-pill-press-mixing-mode}" />
+        </BoxContainer>
+
+        <BoxContainer Name="MixingContainer" Orientation="Vertical" SeparationOverride="4">
+            <!-- Inlet ratio inputs (gas-mixer style) -->
+            <BoxContainer Orientation="Horizontal" HorizontalExpand="True">
+                <Label Text="{Loc plumbing-pill-press-west-ratio}" />
+                <Control MinSize="5 0" />
+                <LineEdit Name="WestRatioInput" PlaceHolder="50" MinSize="60 0" />
+                <Label Text=" %" />
+                <Control MinSize="10 0" />
+                <Label Text="{Loc plumbing-pill-press-east-ratio}" />
+                <Control MinSize="5 0" />
+                <LineEdit Name="EastRatioInput" PlaceHolder="50" MinSize="60 0" />
+                <Label Text=" %" />
+                <Control MinSize="5 0" />
+                <Button Name="SetRatioButton" Text="{Loc plumbing-pill-press-set}" />
+            </BoxContainer>
+        </BoxContainer>
+
+    </BoxContainer>
+</DefaultWindow>
diff --git a/Content.Client/_Starlight/Plumbing/UI/PlumbingPillPressWindow.xaml.cs b/Content.Client/_Starlight/Plumbing/UI/PlumbingPillPressWindow.xaml.cs
new file mode 100644
index 00000000000..051d750dfa7
--- /dev/null
+++ b/Content.Client/_Starlight/Plumbing/UI/PlumbingPillPressWindow.xaml.cs
@@ -0,0 +1,202 @@
+using Content.Shared._Starlight.Plumbing;
+using Content.Shared.Chemistry;
+using Robust.Client.AutoGenerated;
+using Robust.Client.GameObjects;
+using Robust.Client.UserInterface.Controls;
+using Robust.Client.UserInterface.CustomControls;
+using Robust.Client.UserInterface.XAML;
+using Robust.Shared.IoC;
+using Robust.Shared.Localization;
+using Robust.Shared.Utility;
+using System.Numerics;
+
+namespace Content.Client._Starlight.Plumbing.UI;
+
+[GenerateTypedNameReferences]
+public sealed partial class PlumbingPillPressWindow : DefaultWindow
+{
+    [Dependency] private readonly IEntityManager _entityManager = default!;
+
+    public event Action<bool>? OnToggle;
+    public event Action<uint>? OnSetDosage;
+    public event Action<PillPressOutputMode>? OnSetOutputMode;
+    public event Action<uint>? OnSetPillType;
+    public event Action<bool>? OnSetMixing;
+    public event Action<PillPressInlet, float>? OnSetInletRatio;
+
+    private bool _enabled = true;
+    private bool _mixingEnabled;
+    private bool _eastLastEdited = true;
+    private const string PillsRsiPath = "/Textures/Objects/Specific/Chemistry/pills.rsi";
+    private const int PillTypeCount = (int) SharedChemMaster.PillTypes;
+
+    public Button[] PillTypeButtons { get; } = new Button[PillTypeCount];
+
+    public PlumbingPillPressWindow()
+    {
+        RobustXamlLoader.Load(this);
+        IoCManager.InjectDependencies(this);
+
+        ToggleStatusButton.OnPressed += _ =>
+        {
+            _enabled = !_enabled;
+            UpdateToggleButton();
+            OnToggle?.Invoke(_enabled);
+        };
+
+        OutputModeSelector.AddItem(Loc.GetString("plumbing-pill-press-mode-pill"), (int) PillPressOutputMode.Pill);
+        OutputModeSelector.AddItem(Loc.GetString("plumbing-pill-press-mode-patch"), (int) PillPressOutputMode.Patch);
+        OutputModeSelector.OnItemSelected += args =>
+        {
+            OutputModeSelector.SelectId(args.Id);
+            OnSetOutputMode?.Invoke((PillPressOutputMode) args.Id);
+        };
+
+
+        DosageInput.Text = "10";
+        SetDosageButton.OnPressed += _ =>
+        {
+            if (!uint.TryParse(DosageInput.Text, out var val) || val < 1 || val > 20)
+                return;
+            OnSetDosage?.Invoke(val);
+        };
+
+        MixingToggle.OnToggled += args =>
+        {
+            _mixingEnabled = args.Pressed;
+            UpdateMixingVisibility();
+            OnSetMixing?.Invoke(_mixingEnabled);
+        };
+
+        // Ratio inputs: typing in one auto-fills the other
+        EastRatioInput.Text = "50";
+        WestRatioInput.Text = "50";
+
+        EastRatioInput.OnTextChanged += _ =>
+        {
+            _eastLastEdited = true;
+            SetRatioButton.Disabled = false;
+
+            if (float.TryParse(EastRatioInput.Text, out var val))
+            {
+                val = Math.Clamp(val, 0f, 100f);
+                WestRatioInput.Text = ((int)(100f - val)).ToString();
+            }
+        };
+
+        WestRatioInput.OnTextChanged += _ =>
+        {
+            _eastLastEdited = false;
+            SetRatioButton.Disabled = false;
+
+            if (float.TryParse(WestRatioInput.Text, out var val))
+            {
+                val = Math.Clamp(val, 0f, 100f);
+                EastRatioInput.Text = ((int)(100f - val)).ToString();
+            }
+        };
+
+        SetRatioButton.OnPressed += _ =>
+        {
+            // Send whichever was last edited; server sets both (complement)
+            if (_eastLastEdited)
+            {
+                if (!float.TryParse(EastRatioInput.Text, out var val) || val < 0 || val > 100)
+                    return;
+                OnSetInletRatio?.Invoke(PillPressInlet.East, val);
+            }
+            else
+            {
+                if (!float.TryParse(WestRatioInput.Text, out var val) || val < 0 || val > 100)
+                    return;
+                OnSetInletRatio?.Invoke(PillPressInlet.West, val);
+            }
+            SetRatioButton.Disabled = true;
+        };
+
+        MixingContainer.Visible = false;
+
+        // Pill type grid, same pattern as ChemMaster
+        var spriteSystem = _entityManager.System<SpriteSystem>();
+        var resourcePath = new ResPath(PillsRsiPath);
+        var pillTypeGroup = new ButtonGroup();
+
+        for (uint i = 0; i < PillTypeCount; i++)
+        {
+            var styleBase = SpinBox.MiddleButtonStyle;
+
+            // Open-left for first in row, open-right for last in row
+            if (i % 10 == 0)
+                styleBase = SpinBox.LeftButtonStyle;
+            else if (i % 10 == 9)
+                styleBase = SpinBox.RightButtonStyle;
+
+            PillTypeButtons[i] = new Button
+            {
+                StyleClasses = { styleBase },
+                MaxSize = new Vector2(42, 28),
+                Group = pillTypeGroup,
+                ToggleMode = true,
+            };
+
+            var specifier = new SpriteSpecifier.Rsi(resourcePath, "pill" + (i + 1));
+            var pillTypeTexture = new TextureRect
+            {
+                Texture = spriteSystem.Frame0(specifier),
+                TextureScale = new Vector2(1.75f, 1.75f),
+                Stretch = TextureRect.StretchMode.KeepCentered,
+            };
+
+            PillTypeButtons[i].AddChild(pillTypeTexture);
+            PillTypeGrid.AddChild(PillTypeButtons[i]);
+
+            var pillType = i;
+            PillTypeButtons[i].OnPressed += _ =>
+            {
+                OnSetPillType?.Invoke(pillType);
+            };
+        }
+
+        PillTypeButtons[0].Pressed = true;
+    }
+
+    private void UpdateToggleButton()
+    {
+        ToggleStatusButton.Text = _enabled
+            ? Loc.GetString("plumbing-pill-press-enabled")
+            : Loc.GetString("plumbing-pill-press-disabled");
+    }
+
+    private void UpdateMixingVisibility()
+    {
+        MixingContainer.Visible = _mixingEnabled;
+    }
+
+    public void UpdateState(PlumbingPillPressBoundUserInterfaceState state)
+    {
+        _enabled = state.Enabled;
+        UpdateToggleButton();
+
+        // Update dosage don't overwrite while user is typing
+        if (!DosageInput.HasKeyboardFocus())
+            DosageInput.Text = state.Dosage.ToString();
+
+        OutputModeSelector.SelectId((int) state.OutputMode);
+
+        PillTypeContainer.Visible = state.OutputMode == PillPressOutputMode.Pill;
+
+        if (state.PillType < PillTypeCount)
+            PillTypeButtons[state.PillType].Pressed = true;
+
+        _mixingEnabled = state.MixingEnabled;
+        MixingToggle.Pressed = state.MixingEnabled;
+        UpdateMixingVisibility();
+
+        // Update ratio inputs and don't overwrite while user is typing
+        if (!EastRatioInput.HasKeyboardFocus() && !WestRatioInput.HasKeyboardFocus())
+        {
+            EastRatioInput.Text = ((int) state.InletRatioEast).ToString();
+            WestRatioInput.Text = ((int) state.InletRatioWest).ToString();
+        }
+    }
+}
diff --git a/Content.Client/_Starlight/Plumbing/UI/PlumbingReactorBoundUserInterface.cs b/Content.Client/_Starlight/Plumbing/UI/PlumbingReactorBoundUserInterface.cs
new file mode 100644
index 00000000000..4de9dc80d3e
--- /dev/null
+++ b/Content.Client/_Starlight/Plumbing/UI/PlumbingReactorBoundUserInterface.cs
@@ -0,0 +1,64 @@
+using Content.Shared._Starlight.Plumbing;
+using Content.Shared.FixedPoint;
+using JetBrains.Annotations;
+using Robust.Client.UserInterface;
+
+namespace Content.Client._Starlight.Plumbing.UI;
+
+[UsedImplicitly]
+public sealed class PlumbingReactorBoundUserInterface : BoundUserInterface
+{
+    private PlumbingReactorWindow? _window;
+
+    public PlumbingReactorBoundUserInterface(EntityUid owner, Enum uiKey) : base(owner, uiKey)
+    {
+    }
+
+    protected override void Open()
+    {
+        base.Open();
+
+        _window = this.CreateWindow<PlumbingReactorWindow>();
+
+        _window.OnToggle += OnToggle;
+        _window.OnSetTarget += OnSetTarget;
+        _window.OnRemoveTarget += OnRemoveTarget;
+        _window.OnClearTargets += OnClearTargets;
+        _window.OnSetTemperature += OnSetTemperature;
+    }
+
+    private void OnToggle(bool enabled)
+    {
+        SendMessage(new PlumbingReactorToggleMessage(enabled));
+    }
+
+    private void OnSetTarget(string reagentId, FixedPoint2 quantity)
+    {
+        SendMessage(new PlumbingReactorSetTargetMessage(reagentId, quantity));
+    }
+
+    private void OnRemoveTarget(string reagentId)
+    {
+        SendMessage(new PlumbingReactorRemoveTargetMessage(reagentId));
+    }
+
+    private void OnClearTargets()
+    {
+        SendMessage(new PlumbingReactorClearTargetsMessage());
+    }
+
+    private void OnSetTemperature(float temperature)
+    {
+        SendMessage(new PlumbingReactorSetTemperatureMessage(temperature));
+    }
+
+    protected override void UpdateState(BoundUserInterfaceState state)
+    {
+        base.UpdateState(state);
+
+        if (_window == null || state is not PlumbingReactorBoundUserInterfaceState cast)
+            return;
+
+        _window.UpdateState(cast);
+    }
+}
diff --git a/Content.Client/_Starlight/Plumbing/UI/PlumbingReactorWindow.xaml b/Content.Client/_Starlight/Plumbing/UI/PlumbingReactorWindow.xaml
new file mode 100644
index 00000000000..55c2ea11916
--- /dev/null
+++ b/Content.Client/_Starlight/Plumbing/UI/PlumbingReactorWindow.xaml
@@ -0,0 +1,39 @@
+<DefaultWindow xmlns="https://spacestation14.io"
+               xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+               MinSize="400 450" Title="{Loc plumbing-reactor-window-title}">
+    <BoxContainer Orientation="Vertical" Margin="5 5 5 5" SeparationOverride="8">
+        <!-- Status toggle -->
+        <BoxContainer Orientation="Horizontal" HorizontalExpand="True">
+            <Label Text="{Loc plumbing-reactor-status}" />
+            <Button Name="ToggleStatusButton" MinWidth="80" />
+        </BoxContainer>
+
+        <!-- Temperature control -->
+        <BoxContainer Orientation="Horizontal" HorizontalExpand="True" SeparationOverride="5">
+            <Label Text="{Loc plumbing-reactor-temperature}" />
+            <LineEdit Name="TemperatureInput" PlaceHolder="293.15" MinWidth="80" />
+            <Label Name="CurrentTemperatureLabel" Text="(293.15 K)" />
+            <Button Name="SetTemperatureButton" Text="{Loc plumbing-reactor-set}" MinWidth="50" />
+            <Button Name="ResetTemperatureButton" Text="{Loc plumbing-reactor-reset}" MinWidth="50" />
+        </BoxContainer>
+
+        <!-- Add reagent section -->
+        <PanelContainer StyleClasses="LowDivider" />
+        <Label Text="{Loc plumbing-reactor-add-reagent}" StyleClasses="LabelHeading" />
+        <BoxContainer Orientation="Horizontal" HorizontalExpand="True" SeparationOverride="5">
+            <LineEdit Name="ReagentIdInput" PlaceHolder="{Loc plumbing-reactor-reagent-id}" HorizontalExpand="True" />
+            <LineEdit Name="QuantityInput" PlaceHolder="{Loc plumbing-reactor-quantity}" MinWidth="60" />
+            <Button Name="AddTargetButton" Text="{Loc plumbing-reactor-add}" MinWidth="50" />
+        </BoxContainer>
+        <ItemList Name="SuggestionList" SelectMode="Single" MinHeight="80" MaxHeight="120" HorizontalExpand="True" Visible="False" />
+
+        <!-- Targets list (shows current/target) -->
+        <PanelContainer StyleClasses="LowDivider" />
+        <BoxContainer Orientation="Horizontal">
+            <Label Text="{Loc plumbing-reactor-targets}" StyleClasses="LabelHeading" HorizontalExpand="True" />
+            <Button Name="ClearTargetsButton" Text="{Loc plumbing-reactor-clear}" MinWidth="60" />
+        </BoxContainer>
+        <ItemList Name="TargetsList" SelectMode="Single" VerticalExpand="True" MinHeight="100" />
+        <Button Name="RemoveTargetButton" Text="{Loc plumbing-reactor-remove-selected}" Disabled="True" />
+    </BoxContainer>
+</DefaultWindow>
diff --git a/Content.Client/_Starlight/Plumbing/UI/PlumbingReactorWindow.xaml.cs b/Content.Client/_Starlight/Plumbing/UI/PlumbingReactorWindow.xaml.cs
new file mode 100644
index 00000000000..0040fbdcea1
--- /dev/null
+++ b/Content.Client/_Starlight/Plumbing/UI/PlumbingReactorWindow.xaml.cs
@@ -0,0 +1,186 @@
+using Content.Shared._Starlight.Plumbing;
+using Content.Shared.Chemistry.Reagent;
+using Content.Shared.FixedPoint;
+using Robust.Client.AutoGenerated;
+using Robust.Client.UserInterface.Controls;
+using Robust.Client.UserInterface.CustomControls;
+using Robust.Client.UserInterface.XAML;
+using Robust.Shared.IoC;
+using Robust.Shared.Localization;
+using Robust.Shared.Prototypes;
+
+namespace Content.Client._Starlight.Plumbing.UI;
+
+[GenerateTypedNameReferences]
+public sealed partial class PlumbingReactorWindow : DefaultWindow
+{
+    [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
+
+    public event Action<bool>? OnToggle;
+    public event Action<string, FixedPoint2>? OnSetTarget;
+    public event Action<string>? OnRemoveTarget;
+    public event Action? OnClearTargets;
+    public event Action<float>? OnSetTemperature;
+
+    private bool _enabled = true;
+    private string? _selectedTarget;
+
+    public PlumbingReactorWindow()
+    {
+        IoCManager.InjectDependencies(this);
+        RobustXamlLoader.Load(this);
+
+        ToggleStatusButton.OnPressed += _ =>
+        {
+            _enabled = !_enabled;
+            UpdateToggleButton();
+            OnToggle?.Invoke(_enabled);
+        };
+
+        SetTemperatureButton.OnPressed += _ =>
+        {
+            if (!float.TryParse(TemperatureInput.Text, out var temp) || temp < 0)
+                return;
+
+            OnSetTemperature?.Invoke(temp);
+        };
+
+        ResetTemperatureButton.OnPressed += _ =>
+        {
+            TemperatureInput.Text = "293.15";
+            OnSetTemperature?.Invoke(293.15f);
+        };
+
+        AddTargetButton.OnPressed += _ =>
+        {
+            var reagentId = ReagentIdInput.Text.Trim();
+            if (string.IsNullOrEmpty(reagentId))
+                return;
+
+            if (!float.TryParse(QuantityInput.Text, out var qty) || qty <= 0)
+                return;
+
+            OnSetTarget?.Invoke(reagentId, FixedPoint2.New(qty));
+            ReagentIdInput.Text = "";
+            QuantityInput.Text = "";
+            SuggestionList.Visible = false;
+        };
+
+        ReagentIdInput.OnTextChanged += _ => UpdateSuggestions(ReagentIdInput.Text);
+
+        SuggestionList.OnItemSelected += args =>
+        {
+            var selected = args.ItemList[args.ItemIndex].Metadata as string;
+            if (selected != null)
+            {
+                ReagentIdInput.Text = selected;
+                SuggestionList.Visible = false;
+            }
+        };
+
+        RemoveTargetButton.OnPressed += _ =>
+        {
+            if (_selectedTarget != null)
+                OnRemoveTarget?.Invoke(_selectedTarget);
+        };
+
+        ClearTargetsButton.OnPressed += _ => OnClearTargets?.Invoke();
+
+        TargetsList.OnItemSelected += args =>
+        {
+            _selectedTarget = args.ItemList[args.ItemIndex].Metadata as string;
+            RemoveTargetButton.Disabled = _selectedTarget == null;
+        };
+
+        TargetsList.OnItemDeselected += _ =>
+        {
+            _selectedTarget = null;
+            RemoveTargetButton.Disabled = true;
+        };
+    }
+
+    private void UpdateToggleButton()
+    {
+        ToggleStatusButton.Text = _enabled
+            ? Loc.GetString("plumbing-reactor-enabled")
+            : Loc.GetString("plumbing-reactor-disabled");
+    }
+
+    public void UpdateState(PlumbingReactorBoundUserInterfaceState state)
+    {
+        _enabled = state.Enabled;
+        UpdateToggleButton();
+
+        // Update temperature display - but don't overwrite if user is editing
+        if (!TemperatureInput.HasKeyboardFocus())
+            TemperatureInput.Text = state.TargetTemperature.ToString("F1");
+        CurrentTemperatureLabel.Text = $"({state.CurrentTemperature:F1} K)";
+
+        // Update targets list - shows all buffer contents
+        // Target reagents show progress, non-target reagents show 0 target qty
+        TargetsList.Clear();
+
+        // First add all target reagents
+        foreach (var (reagentId, targetQuantity) in state.ReagentTargets)
+        {
+            var currentAmount = state.BufferContents.GetValueOrDefault(reagentId, FixedPoint2.Zero);
+            TargetsList.Add(new ItemList.Item(TargetsList)
+            {
+                Metadata = reagentId,
+                Text = $"{reagentId}: {currentAmount}u / {targetQuantity}u"
+            });
+        }
+
+        // Then add non-target reagents so a player knows to plunger it to remove them
+        foreach (var (reagentId, currentAmount) in state.BufferContents)
+        {
+            if (state.ReagentTargets.ContainsKey(reagentId))
+                continue; 
+
+            TargetsList.Add(new ItemList.Item(TargetsList)
+            {
+                Metadata = reagentId,
+                Text = $"{reagentId}: {currentAmount}u / 0u"
+            });
+        }
+
+        _selectedTarget = null;
+        RemoveTargetButton.Disabled = true;
+    }
+
+    private void UpdateSuggestions(string filter)
+    {
+        SuggestionList.Clear();
+
+        if (string.IsNullOrWhiteSpace(filter))
+        {
+            SuggestionList.Visible = false;
+            return;
+        }
+
+        var lowerFilter = filter.Trim().ToLowerInvariant();
+
+        var matches = new List<ReagentPrototype>();
+
+        foreach (var reagent in _prototypeManager.EnumeratePrototypes<ReagentPrototype>())
+        {
+            if (!reagent.ID.ToLowerInvariant().Contains(lowerFilter))
+                continue;
+
+            matches.Add(reagent);
+        }
+
+        matches.Sort((a, b) => a.ID.Length.CompareTo(b.ID.Length));
+
+        foreach (var reagent in matches)
+        {
+            SuggestionList.Add(new ItemList.Item(SuggestionList)
+            {
+                Metadata = reagent.ID,
+                Text = reagent.ID
+            });
+        }
+
+        SuggestionList.Visible = SuggestionList.Count > 0;
+    }
+}
diff --git a/Content.Client/_Starlight/Plumbing/UI/PlumbingSmartDispenserBoundUserInterface.cs b/Content.Client/_Starlight/Plumbing/UI/PlumbingSmartDispenserBoundUserInterface.cs
new file mode 100644
index 00000000000..0b4ab716e6b
--- /dev/null
+++ b/Content.Client/_Starlight/Plumbing/UI/PlumbingSmartDispenserBoundUserInterface.cs
@@ -0,0 +1,31 @@
+using Content.Shared._Starlight.Plumbing;
+using JetBrains.Annotations;
+using Robust.Client.UserInterface;
+
+namespace Content.Client._Starlight.Plumbing.UI;
+
+[UsedImplicitly]
+public sealed class PlumbingSmartDispenserBoundUserInterface : BoundUserInterface
+{
+    private PlumbingSmartDispenserWindow? _window;
+
+    public PlumbingSmartDispenserBoundUserInterface(EntityUid owner, Enum uiKey) : base(owner, uiKey)
+    {
+    }
+
+    protected override void Open()
+    {
+        base.Open();
+        _window = this.CreateWindow<PlumbingSmartDispenserWindow>();
+    }
+
+    protected override void UpdateState(BoundUserInterfaceState state)
+    {
+        base.UpdateState(state);
+
+        if (_window == null || state is not PlumbingSmartDispenserBuiState cast)
+            return;
+
+        _window.UpdateState(cast);
+    }
+}
diff --git a/Content.Client/_Starlight/Plumbing/UI/PlumbingSmartDispenserWindow.xaml b/Content.Client/_Starlight/Plumbing/UI/PlumbingSmartDispenserWindow.xaml
new file mode 100644
index 00000000000..ee8d5b625a6
--- /dev/null
+++ b/Content.Client/_Starlight/Plumbing/UI/PlumbingSmartDispenserWindow.xaml
@@ -0,0 +1,23 @@
+<DefaultWindow xmlns="https://spacestation14.io"
+               xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+               MinSize="320 450"
+               Title="{Loc plumbing-smart-dispenser-window-title}">
+    <BoxContainer Orientation="Vertical" Margin="5 5 5 5" SeparationOverride="4">
+        <!-- Header -->
+        <Label Text="{Loc plumbing-smart-dispenser-header}" StyleClasses="LabelHeading"
+               HorizontalAlignment="Center" Margin="0 0 0 4" />
+
+        <PanelContainer StyleClasses="LowDivider" />
+
+        <!-- Reagent list -->
+        <ScrollContainer VerticalExpand="True" HorizontalExpand="True" MinHeight="300">
+            <BoxContainer Name="ReagentList" Orientation="Vertical" HorizontalExpand="True"
+                          SeparationOverride="2" />
+        </ScrollContainer>
+
+        <!-- Footer -->
+        <PanelContainer StyleClasses="LowDivider" />
+        <Label Name="StatusLabel" StyleClasses="WindowFooterText"
+               HorizontalAlignment="Center" Margin="0 2 0 0" />
+    </BoxContainer>
+</DefaultWindow>
diff --git a/Content.Client/_Starlight/Plumbing/UI/PlumbingSmartDispenserWindow.xaml.cs b/Content.Client/_Starlight/Plumbing/UI/PlumbingSmartDispenserWindow.xaml.cs
new file mode 100644
index 00000000000..857aa0858dc
--- /dev/null
+++ b/Content.Client/_Starlight/Plumbing/UI/PlumbingSmartDispenserWindow.xaml.cs
@@ -0,0 +1,60 @@
+using Content.Client.Medical.Cryogenics;
+using Content.Shared._Starlight.Plumbing;
+using Content.Shared.FixedPoint;
+using Robust.Client.AutoGenerated;
+using Robust.Client.UserInterface.Controls;
+using Robust.Client.UserInterface.CustomControls;
+using Robust.Client.UserInterface.XAML;
+
+namespace Content.Client._Starlight.Plumbing.UI;
+
+[GenerateTypedNameReferences]
+public sealed partial class PlumbingSmartDispenserWindow : DefaultWindow
+{
+    public PlumbingSmartDispenserWindow()
+    {
+        RobustXamlLoader.Load(this);
+    }
+
+    public void UpdateState(PlumbingSmartDispenserBuiState state)
+    {
+        ReagentList.RemoveAllChildren();
+
+        if (state.Entries.Count == 0)
+        {
+            StatusLabel.Text = Loc.GetString("plumbing-smart-dispenser-empty");
+            return;
+        }
+
+        var totalVolume = FixedPoint2.Zero;
+
+        foreach (var entry in state.Entries)
+        {
+            totalVolume += entry.Quantity;
+
+            var chart = new BeakerBarChart
+            {
+                Capacity = state.MaxPerReagent,
+                HorizontalExpand = true,
+                MinHeight = 24,
+                MaxHeight = 24,
+            };
+
+            chart.Clear();
+            chart.SetEntry(
+                entry.ReagentId,
+                Loc.GetString("plumbing-smart-dispenser-reagent-entry",
+                    ("reagent", entry.LocalizedName),
+                    ("amount", entry.Quantity)),
+                entry.Quantity.Float(),
+                entry.Color,
+                tooltip: $"{entry.LocalizedName}: {entry.Quantity}u / {state.MaxPerReagent}u");
+
+            ReagentList.AddChild(chart);
+        }
+
+        StatusLabel.Text = Loc.GetString("plumbing-smart-dispenser-total",
+            ("total", totalVolume),
+            ("count", state.Entries.Count));
+    }
+}
diff --git a/Content.Client/_Starlight/Plumbing/UI/PlumbingSynthesizerBoundUserInterface.cs b/Content.Client/_Starlight/Plumbing/UI/PlumbingSynthesizerBoundUserInterface.cs
new file mode 100644
index 00000000000..08a22556155
--- /dev/null
+++ b/Content.Client/_Starlight/Plumbing/UI/PlumbingSynthesizerBoundUserInterface.cs
@@ -0,0 +1,45 @@
+using Content.Shared._Starlight.Plumbing;
+using JetBrains.Annotations;
+using Robust.Client.UserInterface;
+
+namespace Content.Client._Starlight.Plumbing.UI;
+
+[UsedImplicitly]
+public sealed class PlumbingSynthesizerBoundUserInterface : BoundUserInterface
+{
+    private PlumbingSynthesizerWindow? _window;
+
+    public PlumbingSynthesizerBoundUserInterface(EntityUid owner, Enum uiKey) : base(owner, uiKey)
+    {
+    }
+
+    protected override void Open()
+    {
+        base.Open();
+
+        _window = this.CreateWindow<PlumbingSynthesizerWindow>();
+
+        _window.OnToggle += OnToggle;
+        _window.OnSelectReagent += OnSelectReagent;
+    }
+
+    private void OnToggle(bool enabled)
+    {
+        SendMessage(new PlumbingSynthesizerToggleMessage(enabled));
+    }
+
+    private void OnSelectReagent(string? reagentId)
+    {
+        SendMessage(new PlumbingSynthesizerSelectReagentMessage(reagentId));
+    }
+
+    protected override void UpdateState(BoundUserInterfaceState state)
+    {
+        base.UpdateState(state);
+
+        if (_window == null || state is not PlumbingSynthesizerBoundUserInterfaceState cast)
+            return;
+
+        _window.UpdateState(cast);
+    }
+}
diff --git a/Content.Client/_Starlight/Plumbing/UI/PlumbingSynthesizerWindow.xaml b/Content.Client/_Starlight/Plumbing/UI/PlumbingSynthesizerWindow.xaml
new file mode 100644
index 00000000000..43a206ca5d2
--- /dev/null
+++ b/Content.Client/_Starlight/Plumbing/UI/PlumbingSynthesizerWindow.xaml
@@ -0,0 +1,22 @@
+<DefaultWindow xmlns="https://spacestation14.io"
+               xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+               MinSize="300 250" Title="{Loc plumbing-synthesizer-window-title}">
+    <BoxContainer Orientation="Vertical" Margin="5 5 5 5" SeparationOverride="8">
+        <!-- Status toggle -->
+        <BoxContainer Orientation="Horizontal" HorizontalExpand="True">
+            <Label Text="{Loc plumbing-synthesizer-status}" />
+            <Button Name="ToggleStatusButton" MinWidth="80" />
+        </BoxContainer>
+
+        <!-- Battery indicator -->
+        <BoxContainer Orientation="Horizontal" HorizontalExpand="True">
+            <Label Text="{Loc plumbing-synthesizer-battery}" />
+            <ProgressBar Name="BatteryBar" HorizontalExpand="True" MinHeight="20" MinValue="0" MaxValue="1" />
+        </BoxContainer>
+
+        <!-- Reagent selection -->
+        <PanelContainer StyleClasses="LowDivider" />
+        <Label Text="{Loc plumbing-synthesizer-select-reagent}" StyleClasses="LabelHeading" />
+        <OptionButton Name="ReagentSelector" HorizontalExpand="True" />
+    </BoxContainer>
+</DefaultWindow>
diff --git a/Content.Client/_Starlight/Plumbing/UI/PlumbingSynthesizerWindow.xaml.cs b/Content.Client/_Starlight/Plumbing/UI/PlumbingSynthesizerWindow.xaml.cs
new file mode 100644
index 00000000000..9022c088e81
--- /dev/null
+++ b/Content.Client/_Starlight/Plumbing/UI/PlumbingSynthesizerWindow.xaml.cs
@@ -0,0 +1,82 @@
+using Content.Shared._Starlight.Plumbing;
+using Robust.Client.AutoGenerated;
+using Robust.Client.UserInterface.Controls;
+using Robust.Client.UserInterface.CustomControls;
+using Robust.Client.UserInterface.XAML;
+using Robust.Shared.Localization;
+
+namespace Content.Client._Starlight.Plumbing.UI;
+
+[GenerateTypedNameReferences]
+public sealed partial class PlumbingSynthesizerWindow : DefaultWindow
+{
+    public event Action<bool>? OnToggle;
+    public event Action<string?>? OnSelectReagent;
+
+    private bool _enabled = true;
+    private readonly Dictionary<int, string> _reagentIndexMap = new();
+
+    public PlumbingSynthesizerWindow()
+    {
+        RobustXamlLoader.Load(this);
+
+        ToggleStatusButton.OnPressed += _ =>
+        {
+            _enabled = !_enabled;
+            UpdateToggleButton();
+            OnToggle?.Invoke(_enabled);
+        };
+
+        ReagentSelector.OnItemSelected += args =>
+        {
+            if (args.Id == 0)
+            {
+                OnSelectReagent?.Invoke(null);
+            }
+            else if (_reagentIndexMap.TryGetValue(args.Id, out var reagentId))
+            {
+                OnSelectReagent?.Invoke(reagentId);
+            }
+        };
+    }
+
+    private void UpdateToggleButton()
+    {
+        ToggleStatusButton.Text = _enabled
+            ? Loc.GetString("plumbing-synthesizer-enabled")
+            : Loc.GetString("plumbing-synthesizer-disabled");
+    }
+
+    public void UpdateState(PlumbingSynthesizerBoundUserInterfaceState state)
+    {
+        _enabled = state.Enabled;
+        UpdateToggleButton();
+
+        BatteryBar.Value = state.BatteryCharge;
+
+        _reagentIndexMap.Clear();
+        ReagentSelector.Clear();
+
+        ReagentSelector.AddItem(Loc.GetString("plumbing-synthesizer-none"), 0);
+
+        var sortedReagents = new List<string>(state.GeneratableReagents.Keys);
+        sortedReagents.Sort();
+
+        var idx = 1;
+        var selectedIdx = 0;
+        foreach (var reagentId in sortedReagents)
+        {
+            var powerDrain = state.GeneratableReagents[reagentId];
+            var label = $"{reagentId} ({powerDrain:F1}W/u)";
+            ReagentSelector.AddItem(label, idx);
+            _reagentIndexMap[idx] = reagentId;
+
+            if (state.SelectedReagent == reagentId)
+                selectedIdx = idx;
+
+            idx++;
+        }
+
+        ReagentSelector.SelectId(selectedIdx);
+    }
+}
diff --git a/Content.Server/_Starlight/Plumbing/Components/PlumbingDeviceComponent.cs b/Content.Server/_Starlight/Plumbing/Components/PlumbingDeviceComponent.cs
new file mode 100644
index 00000000000..8801b0a0834
--- /dev/null
+++ b/Content.Server/_Starlight/Plumbing/Components/PlumbingDeviceComponent.cs
@@ -0,0 +1,50 @@
+using Robust.Shared.Audio;
+using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom;
+
+namespace Content.Server._Starlight.Plumbing.Components;
+
+/// <summary>
+///     Component for plumbing devices which are updated by the plumbing system.
+///     Add this to any entity that should receive <see cref="PlumbingDeviceUpdateEvent"/>.
+/// </summary>
+[RegisterComponent, AutoGenerateComponentPause]
+public sealed partial class PlumbingDeviceComponent : Component
+{
+    /// <summary>
+    ///     If true, this device must be anchored before it will receive updates.
+    /// </summary>
+    [DataField]
+    public bool RequireAnchored = true;
+
+    /// <summary>
+    ///     How often reagents are transferred (on an update).
+    /// </summary>
+    [DataField]
+    public TimeSpan UpdateInterval = TimeSpan.FromSeconds(2);
+
+    /// <summary>
+    ///     Sound played when a UI button is clicked (toggle, select, etc.).
+    /// </summary>
+    [DataField]
+    public SoundSpecifier ClickSound = new SoundPathSpecifier("/Audio/Machines/machine_switch.ogg");
+
+    /// <summary>
+    ///     The next time this device should be updated.
+    ///     Automatically adjusted when entity is unpaused.
+    /// </summary>
+    [DataField(customTypeSerializer: typeof(TimeOffsetSerializer)), AutoPausedField]
+    public TimeSpan NextUpdateTime;
+}
+
+/// <summary>
+///     Raised on a plumbing device when it should process/transfer reagents.
+///     Subscribe to this event in your system to handle device-specific logic.
+/// </summary>
+[ByRefEvent]
+public readonly struct PlumbingDeviceUpdateEvent(float dt)
+{
+    /// <summary>
+    ///     Time since last update in seconds. Used for time-based calculations (just the reactor heating for now)
+    /// </summary>
+    public readonly float dt = dt;
+}
diff --git a/Content.Server/_Starlight/Plumbing/EntitySystems/PlumbingConnectorAppearanceSystem.cs b/Content.Server/_Starlight/Plumbing/EntitySystems/PlumbingConnectorAppearanceSystem.cs
new file mode 100644
index 00000000000..d1c67666aad
--- /dev/null
+++ b/Content.Server/_Starlight/Plumbing/EntitySystems/PlumbingConnectorAppearanceSystem.cs
@@ -0,0 +1,194 @@
+using Content.Server._Starlight.Plumbing.Nodes;
+using Content.Server.NodeContainer.EntitySystems;
+using Content.Server.NodeContainer.Nodes;
+using Content.Shared._Starlight.Plumbing;
+using Content.Shared._Starlight.Plumbing.Components;
+using Content.Shared.Atmos;
+using Content.Shared.Maps;
+using Content.Shared.NodeContainer;
+using Robust.Shared.Map;
+using Robust.Shared.Map.Components;
+
+namespace Content.Server._Starlight.Plumbing.EntitySystems;
+
+/// <summary>
+///     Server system that sends PlumbingNode directions and connection state to clients.
+///     Also tracks floor coverage to hide connectors under floor tiles.
+/// </summary>
+public sealed class PlumbingConnectorAppearanceSystem : EntitySystem
+{
+    [Dependency] private readonly SharedAppearanceSystem _appearance = default!;
+    [Dependency] private readonly SharedMapSystem _map = default!;
+    [Dependency] private readonly ITileDefinitionManager _tileDefManager = default!;
+
+    private static readonly PipeDirection[] CardinalDirections =
+    [
+        PipeDirection.North,
+        PipeDirection.South,
+        PipeDirection.East,
+        PipeDirection.West
+    ];
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<PlumbingConnectorAppearanceComponent, NodeGroupsRebuilt>(OnNodeUpdate);
+        SubscribeLocalEvent<PlumbingConnectorAppearanceComponent, ComponentStartup>(OnStartup);
+        SubscribeLocalEvent<TileChangedEvent>(OnTileChanged);
+    }
+
+    private void OnStartup(EntityUid uid, PlumbingConnectorAppearanceComponent component, ComponentStartup args)
+    {
+        UpdateAppearance(uid);
+    }
+
+    private void OnNodeUpdate(EntityUid uid, PlumbingConnectorAppearanceComponent component, ref NodeGroupsRebuilt args)
+    {
+        UpdateAppearance(args.NodeOwner);
+    }
+
+    private void OnTileChanged(ref TileChangedEvent ev)
+    {
+        var grid = ev.Entity.Comp;
+
+        foreach (var change in ev.Changes)
+        {
+            foreach (var uid in _map.GetAnchoredEntities(ev.Entity, grid, change.GridIndices))
+            {
+                if (HasComp<PlumbingConnectorAppearanceComponent>(uid))
+                    UpdateAppearance(uid);
+            }
+        }
+    }
+
+    private bool HasFloorCover(EntityUid gridUid, MapGridComponent grid, Vector2i position)
+    {
+        var tileRef = _map.GetTileRef(gridUid, grid, position);
+        var tileDef = (ContentTileDefinition)_tileDefManager[tileRef.Tile.TypeId];
+        return !tileDef.IsSubFloor;
+    }
+
+    private void UpdateAppearance(EntityUid uid, AppearanceComponent? appearance = null,
+        NodeContainerComponent? container = null, TransformComponent? xform = null)
+    {
+        if (!Resolve(uid, ref appearance, ref container, ref xform, false))
+            return;
+
+        if (!TryComp<MapGridComponent>(xform.GridUid, out var grid))
+            return;
+
+        if (!TryComp<PlumbingConnectorAppearanceComponent>(uid, out var connectorComp))
+            return;
+
+        var tile = _map.TileIndicesFor(xform.GridUid.Value, grid, xform.Coordinates);
+
+        var nodeDirections = PipeDirection.None;
+        var connectedDirections = PipeDirection.None;
+        var inletDirections = PipeDirection.None;
+        var outletDirections = PipeDirection.None;
+        var mixingInletDirections = PipeDirection.None;
+
+        TryComp<PlumbingInletComponent>(uid, out var inletComp);
+        TryComp<PlumbingOutletComponent>(uid, out var outletComp);
+
+        foreach (var (nodeName, node) in container.Nodes)
+        {
+            if (node is not PlumbingNode plumbingNode)
+                continue;
+
+            var nodeDir = plumbingNode.CurrentPipeDirection;
+            nodeDirections |= nodeDir;
+
+            if (connectorComp.MixingInletNames.Contains(nodeName))
+            {
+                mixingInletDirections |= nodeDir;
+            }
+            // Classify as inlet/outlet based on component match OR node name fallback
+            else
+            {
+                var isInlet = false;
+                if (inletComp != null)
+                {
+                    foreach (var inletName in inletComp.InletNames)
+                    {
+                        if (nodeName.Equals(inletName, StringComparison.OrdinalIgnoreCase))
+                        {
+                            isInlet = true;
+                            break;
+                        }
+                    }
+                }
+
+                var isOutlet = false;
+                if (outletComp != null)
+                {
+                    foreach (var outletName in outletComp.OutletNames)
+                    {
+                        if (nodeName.Equals(outletName, StringComparison.OrdinalIgnoreCase))
+                        {
+                            isOutlet = true;
+                            break;
+                        }
+                    }
+                }
+
+                // Fallback: any node literally named "inlet" is colored as inlet
+                if (!isInlet && !isOutlet && nodeName.Equals("inlet", StringComparison.OrdinalIgnoreCase))
+                    isInlet = true;
+
+                if (isInlet)
+                    inletDirections |= nodeDir;
+                else if (isOutlet)
+                    outletDirections |= nodeDir;
+            }
+
+            connectedDirections |= GetConnectedDirections(node, nodeDir, tile, xform.GridUid.Value, grid);
+        }
+
+        var coveredByFloor = HasFloorCover(xform.GridUid.Value, grid, tile);
+
+        _appearance.SetData(uid, PlumbingVisuals.NodeDirections, (int)nodeDirections, appearance);
+        _appearance.SetData(uid, PlumbingVisuals.ConnectedDirections, (int)connectedDirections, appearance);
+        _appearance.SetData(uid, PlumbingVisuals.InletDirections, (int)inletDirections, appearance);
+        _appearance.SetData(uid, PlumbingVisuals.OutletDirections, (int)outletDirections, appearance);
+        _appearance.SetData(uid, PlumbingVisuals.MixingInletDirections, (int)mixingInletDirections, appearance);
+        _appearance.SetData(uid, PlumbingVisuals.CoveredByFloor, coveredByFloor, appearance);
+    }
+
+    private PipeDirection GetConnectedDirections(Node node, PipeDirection nodeDir, Vector2i tile,
+        EntityUid gridUid, MapGridComponent grid)
+    {
+        var connected = PipeDirection.None;
+
+        foreach (var dir in CardinalDirections)
+        {
+            if (!nodeDir.HasFlag(dir))
+                continue;
+
+            var neighborTile = dir switch
+            {
+                PipeDirection.North => tile + (0, 1),
+                PipeDirection.South => tile + (0, -1),
+                PipeDirection.East => tile + (1, 0),
+                PipeDirection.West => tile + (-1, 0),
+                _ => tile
+            };
+
+            foreach (var reachable in node.ReachableNodes)
+            {
+                if (reachable is not PlumbingNode || reachable.Owner == node.Owner)
+                    continue;
+
+                var otherTile = _map.TileIndicesFor(gridUid, grid, Transform(reachable.Owner).Coordinates);
+                if (otherTile == neighborTile)
+                {
+                    connected |= dir;
+                    break;
+                }
+            }
+        }
+
+        return connected;
+    }
+}
diff --git a/Content.Server/_Starlight/Plumbing/EntitySystems/PlumbingDeviceSystem.cs b/Content.Server/_Starlight/Plumbing/EntitySystems/PlumbingDeviceSystem.cs
new file mode 100644
index 00000000000..64b6edb8321
--- /dev/null
+++ b/Content.Server/_Starlight/Plumbing/EntitySystems/PlumbingDeviceSystem.cs
@@ -0,0 +1,136 @@
+using Content.Server._Starlight.Plumbing.Components;
+using Content.Server.Fluids.EntitySystems;
+using Content.Server.Popups;
+using Content.Shared._Starlight.Plumbing;
+using Content.Shared._Starlight.Plumbing.Components;
+using Content.Shared.Chemistry.Components.SolutionManager;
+using Content.Shared.Chemistry.EntitySystems;
+using Content.Shared.FixedPoint;
+using Content.Shared.Interaction;
+using Content.Shared.Tag;
+using JetBrains.Annotations;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
+using Robust.Shared.Random;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Timing;
+using SharedAppearanceSystem = Robust.Shared.GameObjects.SharedAppearanceSystem;
+
+namespace Content.Server._Starlight.Plumbing.EntitySystems;
+
+/// <summary>
+///     Manages plumbing devices and raises update events on them.
+///     Individual device logic is handled by subscribing to <see cref="PlumbingDeviceUpdateEvent"/>.
+///     Also handles plunger interactions for draining plumbing machines.
+/// </summary>
+[UsedImplicitly]
+public sealed class PlumbingDeviceSystem : EntitySystem
+{
+    [Dependency] private readonly IGameTiming _timing = default!;
+    [Dependency] private readonly IRobustRandom _random = default!;
+    [Dependency] private readonly SharedSolutionContainerSystem _solutionSystem = default!;
+    [Dependency] private readonly PuddleSystem _puddleSystem = default!;
+    [Dependency] private readonly PopupSystem _popup = default!;
+    [Dependency] private readonly SharedAudioSystem _audio = default!;
+    [Dependency] private readonly TagSystem _tag = default!;
+    [Dependency] private readonly SharedAppearanceSystem _appearance = default!;
+
+    private EntityQuery<TransformComponent> _xformQuery;
+
+    private static readonly ProtoId<TagPrototype> PlungerTag = "Plunger";
+
+    public override void Initialize()
+    {
+        base.Initialize();
+        _xformQuery = GetEntityQuery<TransformComponent>();
+
+        SubscribeLocalEvent<PlungeableComponent, InteractUsingEvent>(OnPlungeableInteractUsing);
+        SubscribeLocalEvent<PlumbingDeviceComponent, AnchorStateChangedEvent>(OnAnchorChanged);
+    }
+
+    /// <summary>
+    ///     When a plumbing device is unanchored, stop its running animation.
+    /// </summary>
+    private void OnAnchorChanged(Entity<PlumbingDeviceComponent> ent, ref AnchorStateChangedEvent args)
+    {
+        if (!args.Anchored && ent.Comp.RequireAnchored)
+            _appearance.SetData(ent.Owner, PlumbingVisuals.Running, false);
+    }
+
+    public override void Update(float frameTime)
+    {
+        base.Update(frameTime);
+
+        var curTime = _timing.CurTime;
+
+        var devicesToUpdate = new List<(EntityUid Uid, PlumbingDeviceComponent Device)>();
+
+        var query = EntityQueryEnumerator<PlumbingDeviceComponent>();
+        while (query.MoveNext(out var uid, out var device))
+        {
+            // Cached query for better performance
+            if (device.RequireAnchored && (!_xformQuery.TryGetComponent(uid, out var xform) || !xform.Anchored))
+                continue;
+
+            if (curTime < device.NextUpdateTime)
+                continue;
+
+            devicesToUpdate.Add((uid, device));
+        }
+
+        // Shuffle to ensure fair distribution when multiple devices pull from same network
+        _random.Shuffle(devicesToUpdate);
+
+        foreach (var (uid, device) in devicesToUpdate)
+        {
+            device.NextUpdateTime = curTime + device.UpdateInterval;
+
+            var ev = new PlumbingDeviceUpdateEvent((float)device.UpdateInterval.TotalSeconds);
+            RaiseLocalEvent(uid, ref ev);
+        }
+    }
+
+    /// <summary>
+    ///     Handles plunger interactions to drain all solutions from a plungeable machine.
+    /// </summary>
+    private void OnPlungeableInteractUsing(Entity<PlungeableComponent> ent, ref InteractUsingEvent args)
+    {
+        if (args.Handled)
+            return;
+
+        if (!_tag.HasTag(args.Used, PlungerTag))
+            return;
+
+        if (!TryComp<SolutionContainerManagerComponent>(ent.Owner, out var solutionManager))
+            return;
+
+        var totalDrained = FixedPoint2.Zero;
+        var coords = Transform(ent.Owner).Coordinates;
+
+        foreach (var (name, soln) in _solutionSystem.EnumerateSolutions((ent.Owner, solutionManager)))
+        {
+            var solution = soln.Comp.Solution;
+
+            if (solution.Volume <= 0)
+                continue;
+
+            // Drain all contents and spill onto floor
+            var drained = _solutionSystem.SplitSolution(soln, solution.Volume);
+            totalDrained += drained.Volume;
+
+            _puddleSystem.TrySpillAt(coords, drained, out _);
+        }
+
+        if (totalDrained > 0)
+        {
+            _popup.PopupEntity(Loc.GetString("plumbing-drain-success", ("amount", totalDrained)), ent.Owner, args.User);
+            _audio.PlayPvs(ent.Comp.DrainSound, ent.Owner);
+        }
+        else
+        {
+            _popup.PopupEntity(Loc.GetString("plumbing-drain-empty"), ent.Owner, args.User);
+        }
+
+        args.Handled = true;
+    }
+}
diff --git a/Content.Server/_Starlight/Plumbing/EntitySystems/PlumbingFilterSystem.cs b/Content.Server/_Starlight/Plumbing/EntitySystems/PlumbingFilterSystem.cs
new file mode 100644
index 00000000000..39aeebf14ec
--- /dev/null
+++ b/Content.Server/_Starlight/Plumbing/EntitySystems/PlumbingFilterSystem.cs
@@ -0,0 +1,134 @@
+using Content.Server._Starlight.Plumbing.Components;
+using Content.Server.Popups;
+using Content.Server.UserInterface;
+using Content.Shared._Starlight.Plumbing;
+using Content.Shared._Starlight.Plumbing.Components;
+using Content.Shared.Chemistry.EntitySystems;
+using Content.Shared.Chemistry.Reagent;
+using JetBrains.Annotations;
+using Robust.Server.GameObjects;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
+using Robust.Shared.Prototypes;
+
+namespace Content.Server._Starlight.Plumbing.EntitySystems;
+
+/// <summary>
+///     Handles plumbing filter behavior - pulls from inlet into a single buffer container.
+///     The buffer has two outlet nodes with restricted pulling:
+///     - Filter outlet: only allows pulling reagents matching the filter list
+///     - Passthrough outlet: only allows pulling reagents NOT matching the filter list
+///     Restriction is enforced via PlumbingPullAttemptEvent.
+/// </summary>
+[UsedImplicitly]
+public sealed class PlumbingFilterSystem : EntitySystem
+{
+    [Dependency] private readonly UserInterfaceSystem _ui = default!;
+    [Dependency] private readonly PopupSystem _popup = default!;
+    [Dependency] private readonly SharedAudioSystem _audio = default!;
+    [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<PlumbingFilterComponent, PlumbingPullAttemptEvent>(OnPullAttempt);
+        SubscribeLocalEvent<PlumbingFilterComponent, PlumbingFilterToggleMessage>(OnToggle);
+        SubscribeLocalEvent<PlumbingFilterComponent, PlumbingFilterAddReagentMessage>(OnAddReagent);
+        SubscribeLocalEvent<PlumbingFilterComponent, PlumbingFilterRemoveReagentMessage>(OnRemoveReagent);
+        SubscribeLocalEvent<PlumbingFilterComponent, PlumbingFilterClearMessage>(OnClear);
+        SubscribeLocalEvent<PlumbingFilterComponent, BoundUIOpenedEvent>(OnUIOpened);
+    }
+
+    /// <summary>
+    ///     Handles pull attempts - restricts which reagents can be pulled based on outlet node.
+    /// </summary>
+    private void OnPullAttempt(Entity<PlumbingFilterComponent> ent, ref PlumbingPullAttemptEvent args)
+    {
+        // When disabled, block the filter outlet entirely — everything goes through passthrough
+        if (!ent.Comp.Enabled)
+        {
+            if (args.NodeName == ent.Comp.FilterNodeName)
+                args.Cancelled = true;
+            return;
+        }
+
+        var isFilteredReagent = ent.Comp.FilteredReagents.Contains(args.ReagentPrototype);
+
+        if (args.NodeName == ent.Comp.FilterNodeName)
+        {
+            if (!isFilteredReagent)
+                args.Cancelled = true;
+        }
+        else if (args.NodeName == ent.Comp.PassthroughNodeName)
+        {
+            if (isFilteredReagent)
+                args.Cancelled = true;
+        }
+    }
+
+    private void OnToggle(Entity<PlumbingFilterComponent> ent, ref PlumbingFilterToggleMessage args)
+    {
+        ent.Comp.Enabled = args.Enabled;
+        DirtyField(ent, ent.Comp, nameof(PlumbingFilterComponent.Enabled));
+        ClickSound(ent.Owner);
+        UpdateUI(ent);
+    }
+
+    private void OnAddReagent(Entity<PlumbingFilterComponent> ent, ref PlumbingFilterAddReagentMessage args)
+    {
+        if (!_prototypeManager.HasIndex<ReagentPrototype>(args.ReagentId))
+        {
+            _popup.PopupEntity(Loc.GetString("plumbing-filter-invalid-reagent", ("reagent", args.ReagentId)), ent.Owner, args.Actor);
+            return;
+        }
+
+        ent.Comp.FilteredReagents.Add(new ProtoId<ReagentPrototype>(args.ReagentId));
+        DirtyField(ent, ent.Comp, nameof(PlumbingFilterComponent.FilteredReagents));
+        ClickSound(ent.Owner);
+        UpdateUI(ent);
+    }
+
+    private void OnRemoveReagent(Entity<PlumbingFilterComponent> ent, ref PlumbingFilterRemoveReagentMessage args)
+    {
+        ent.Comp.FilteredReagents.Remove(new ProtoId<ReagentPrototype>(args.ReagentId));
+        DirtyField(ent, ent.Comp, nameof(PlumbingFilterComponent.FilteredReagents));
+        ClickSound(ent.Owner);
+        UpdateUI(ent);
+    }
+
+    private void OnClear(Entity<PlumbingFilterComponent> ent, ref PlumbingFilterClearMessage args)
+    {
+        ent.Comp.FilteredReagents.Clear();
+        DirtyField(ent, ent.Comp, nameof(PlumbingFilterComponent.FilteredReagents));
+        ClickSound(ent.Owner);
+        UpdateUI(ent);
+    }
+
+    private void OnUIOpened(Entity<PlumbingFilterComponent> ent, ref BoundUIOpenedEvent args)
+    {
+        UpdateUI(ent);
+    }
+
+    private void UpdateUI(Entity<PlumbingFilterComponent> ent)
+    {
+        // Convert ProtoId to string for UI state
+        var filteredReagents = new HashSet<string>();
+        foreach (var protoId in ent.Comp.FilteredReagents)
+        {
+            filteredReagents.Add(protoId.Id);
+        }
+
+        var state = new PlumbingFilterBoundUserInterfaceState(
+            filteredReagents,
+            ent.Comp.Enabled);
+
+        _ui.SetUiState(ent.Owner, PlumbingFilterUiKey.Key, state);
+    }
+
+    private void ClickSound(EntityUid uid)
+    {
+        if (TryComp<PlumbingDeviceComponent>(uid, out var device))
+            _audio.PlayPvs(device.ClickSound, uid, AudioParams.Default.WithVolume(-2f));
+    }
+}
diff --git a/Content.Server/_Starlight/Plumbing/EntitySystems/PlumbingInletSystem.cs b/Content.Server/_Starlight/Plumbing/EntitySystems/PlumbingInletSystem.cs
new file mode 100644
index 00000000000..5aa0baca5f9
--- /dev/null
+++ b/Content.Server/_Starlight/Plumbing/EntitySystems/PlumbingInletSystem.cs
@@ -0,0 +1,64 @@
+using Content.Server._Starlight.Plumbing.Components;
+using Content.Server._Starlight.Plumbing.Nodes;
+using Content.Server.NodeContainer.EntitySystems;
+using Content.Shared._Starlight.Plumbing.Components;
+using Content.Shared.Chemistry.EntitySystems;
+using Content.Shared.FixedPoint;
+using Content.Shared.NodeContainer;
+using JetBrains.Annotations;
+
+namespace Content.Server._Starlight.Plumbing.EntitySystems;
+
+/// <summary>
+///     Handles plumbing inlet behavior: actively pulls reagents from inlet nodes into a solution.
+/// </summary>
+[UsedImplicitly]
+public sealed class PlumbingInletSystem : EntitySystem
+{
+    [Dependency] private readonly SharedSolutionContainerSystem _solutionSystem = default!;
+    [Dependency] private readonly PlumbingPullSystem _pullSystem = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+        SubscribeLocalEvent<PlumbingInletComponent, PlumbingDeviceUpdateEvent>(OnInletUpdate);
+    }
+
+    private void OnInletUpdate(Entity<PlumbingInletComponent> ent, ref PlumbingDeviceUpdateEvent args)
+    {
+        // When the pill press is in mixing mode, don't pull from the normal inlet
+        // mixing inlets handle all pulling instead.
+        if (TryComp<PlumbingPillPressComponent>(ent.Owner, out var pillPress) && pillPress.MixingEnabled)
+            return;
+
+        if (!_solutionSystem.TryGetSolution(ent.Owner, ent.Comp.SolutionName, out var solutionEnt, out var solution))
+            return;
+            
+        if (solution.AvailableVolume <= 0)
+            return;
+
+        if (!TryComp<NodeContainerComponent>(ent.Owner, out var nodeContainer))
+            return;
+
+        // Pull from each inlet's network independently, sharing a single transfer budget
+        // so total throughput stays at TransferAmount regardless of inlet count.
+        var remaining = ent.Comp.TransferAmount;
+
+        foreach (var inletName in ent.Comp.InletNames)
+        {
+            if (remaining <= 0 || solution.AvailableVolume <= 0)
+                break;
+
+            if (!nodeContainer.Nodes.TryGetValue(inletName, out var node))
+                continue;
+
+            if (node is not PlumbingNode plumbingNode || plumbingNode.PlumbingNet == null)
+                continue;
+
+            var roundRobinIndex = ent.Comp.RoundRobinIndices.GetValueOrDefault(inletName, 0);
+            var (pulled, nextIndex) = _pullSystem.PullFromNetwork(ent.Owner, plumbingNode.PlumbingNet, solutionEnt.Value, remaining, roundRobinIndex);
+            ent.Comp.RoundRobinIndices[inletName] = nextIndex;
+            remaining -= pulled;
+        }
+    }
+}
diff --git a/Content.Server/_Starlight/Plumbing/EntitySystems/PlumbingInputSystem.cs b/Content.Server/_Starlight/Plumbing/EntitySystems/PlumbingInputSystem.cs
new file mode 100644
index 00000000000..e0ddb2f67d1
--- /dev/null
+++ b/Content.Server/_Starlight/Plumbing/EntitySystems/PlumbingInputSystem.cs
@@ -0,0 +1,59 @@
+using Content.Server.Popups;
+using Content.Shared._Starlight.Plumbing.Components;
+using Content.Shared.Chemistry.Components;
+using Content.Shared.Chemistry.EntitySystems;
+using Content.Shared.FixedPoint;
+using Content.Shared.Interaction;
+using JetBrains.Annotations;
+
+
+namespace Content.Server._Starlight.Plumbing.EntitySystems;
+
+/// <summary>
+///     Handles plumbing input machine behavior: A small tank (with no inlets) that players can pour reagents into.
+/// </summary>
+[UsedImplicitly]
+public sealed class PlumbingInputSystem : EntitySystem
+{
+    [Dependency] private readonly SharedSolutionContainerSystem _solutionSystem = default!;
+    [Dependency] private readonly PopupSystem _popup = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<PlumbingInputComponent, InteractUsingEvent>(OnInputInteractUsing);
+    }
+
+    private void OnInputInteractUsing(Entity<PlumbingInputComponent> ent, ref InteractUsingEvent args)
+    {
+        if (args.Handled)
+            return;
+
+        if (!_solutionSystem.TryGetDrainableSolution(args.Used, out var drainableSolutionEnt, out var drainableSolution))
+            return;
+
+        if (!_solutionSystem.TryGetSolution(ent.Owner, ent.Comp.SolutionName, out var inputSolutionEnt, out var inputSolution))
+            return;
+
+        var transferAmount = drainableSolution.Volume;
+        if (TryComp<SolutionTransferComponent>(args.Used, out var transferComp))
+            transferAmount = FixedPoint2.Min(transferAmount, transferComp.TransferAmount);
+
+        var space = inputSolution.AvailableVolume;
+        var toTransfer = FixedPoint2.Min(transferAmount, space);
+
+        if (toTransfer <= 0)
+        {
+            _popup.PopupEntity(Loc.GetString("plumbing-input-full"), ent.Owner, args.User);
+            return;
+        }
+
+        var split = _solutionSystem.SplitSolution(drainableSolutionEnt.Value, toTransfer);
+        _solutionSystem.TryAddSolution(inputSolutionEnt.Value, split);
+
+        _popup.PopupEntity(Loc.GetString("plumbing-input-poured", ("amount", toTransfer)), ent.Owner, args.User);
+
+        args.Handled = true;
+    }
+}
diff --git a/Content.Server/_Starlight/Plumbing/EntitySystems/PlumbingOutputSystem.cs b/Content.Server/_Starlight/Plumbing/EntitySystems/PlumbingOutputSystem.cs
new file mode 100644
index 00000000000..3caa6215d28
--- /dev/null
+++ b/Content.Server/_Starlight/Plumbing/EntitySystems/PlumbingOutputSystem.cs
@@ -0,0 +1,60 @@
+using Content.Server._Starlight.Plumbing.Components;
+using Content.Server.Popups;
+using Content.Shared._Starlight.Plumbing.Components;
+using Content.Shared.Chemistry.Components;
+using Content.Shared.Chemistry.EntitySystems;
+using Content.Shared.FixedPoint;
+using Content.Shared.Interaction;
+using JetBrains.Annotations;
+
+
+namespace Content.Server._Starlight.Plumbing.EntitySystems;
+
+/// <summary>
+///     Handles plumbing output machine behavior: A small tank that players can draw reagents from.
+///     Pulling from the network is handled by <see cref="PlumbingInletSystem"/> via <see cref="PlumbingInletComponent"/>.
+/// </summary>
+[UsedImplicitly]
+public sealed class PlumbingOutputSystem : EntitySystem
+{
+    [Dependency] private readonly SharedSolutionContainerSystem _solutionSystem = default!;
+    [Dependency] private readonly PopupSystem _popup = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+        SubscribeLocalEvent<PlumbingOutputComponent, InteractUsingEvent>(OnOutputInteractUsing);
+    }
+
+    private void OnOutputInteractUsing(Entity<PlumbingOutputComponent> ent, ref InteractUsingEvent args)
+    {
+        if (args.Handled)
+            return;
+
+        if (!_solutionSystem.TryGetRefillableSolution(args.Used, out var refillableSolutionEnt, out var refillableSolution))
+            return;
+
+        if (!_solutionSystem.TryGetSolution(ent.Owner, ent.Comp.SolutionName, out var outputSolutionEnt, out var outputSolution))
+            return;
+
+        var transferAmount = outputSolution.Volume;
+        if (TryComp<SolutionTransferComponent>(args.Used, out var transferComp))
+            transferAmount = FixedPoint2.Min(transferAmount, transferComp.TransferAmount);
+
+        var space = refillableSolution.AvailableVolume;
+        var toTransfer = FixedPoint2.Min(transferAmount, space);
+
+        if (toTransfer <= 0)
+        {
+            _popup.PopupEntity(Loc.GetString("plumbing-output-empty"), ent.Owner, args.User);
+            return;
+        }
+
+        var split = _solutionSystem.SplitSolution(outputSolutionEnt.Value, toTransfer);
+        _solutionSystem.TryAddSolution(refillableSolutionEnt.Value, split);
+
+        _popup.PopupEntity(Loc.GetString("plumbing-output-filled", ("amount", toTransfer)), ent.Owner, args.User);
+
+        args.Handled = true;
+    }
+}
diff --git a/Content.Server/_Starlight/Plumbing/EntitySystems/PlumbingPillPressSystem.cs b/Content.Server/_Starlight/Plumbing/EntitySystems/PlumbingPillPressSystem.cs
new file mode 100644
index 00000000000..1f04587b36f
--- /dev/null
+++ b/Content.Server/_Starlight/Plumbing/EntitySystems/PlumbingPillPressSystem.cs
@@ -0,0 +1,335 @@
+using System.Numerics;
+using Content.Server._Starlight.Plumbing.Components;
+using Content.Server._Starlight.Plumbing.Nodes;
+using Content.Shared.Starlight.Medical.Items.Components;
+using Content.Shared._Starlight.Plumbing;
+using Content.Shared._Starlight.Plumbing.Components;
+using Content.Shared.Chemistry;
+using Content.Shared.Chemistry.Components;
+using Content.Shared.Chemistry.EntitySystems;
+using Content.Shared.Chemistry.Reagent;
+using Content.Shared.FixedPoint;
+using Content.Shared.NodeContainer;
+using Content.Shared.UserInterface;
+using JetBrains.Annotations;
+using Robust.Server.GameObjects;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
+using Robust.Shared.Map;
+using Robust.Shared.Prototypes;
+using SharedAppearanceSystem = Robust.Shared.GameObjects.SharedAppearanceSystem;
+
+namespace Content.Server._Starlight.Plumbing.EntitySystems;
+
+/// <summary>
+///     Handles the plumbing pill press: pulls reagents from the inlet network into a buffer,
+///     and automatically creates pills or patches when the buffer has enough for the set dosage.
+///     Supports optional mixing mode with two ratio-controlled inlets (E/W).
+/// </summary>
+[UsedImplicitly]
+public sealed class PlumbingPillPressSystem : EntitySystem
+{
+    [Dependency] private readonly SharedSolutionContainerSystem _solutionSystem = default!;
+    [Dependency] private readonly UserInterfaceSystem _ui = default!;
+    [Dependency] private readonly SharedAudioSystem _audio = default!;
+    [Dependency] private readonly SharedAppearanceSystem _appearance = default!;
+    [Dependency] private readonly PlumbingPullSystem _pullSystem = default!;
+    [Dependency] private readonly EntityLookupSystem _lookup = default!;
+
+    private static readonly EntProtoId PillPrototypeId = "Pill";
+    private static readonly EntProtoId PatchPrototypeId = "Patch";
+    private const int MaxOutputEntitiesOnTile = 30;
+
+    /// <summary>Max dosage matches the ChemMaster limit.</summary>
+    private const uint MaxDosage = 20;
+    private const uint MinDosage = 1;
+    private const uint MaxPillTypes = SharedChemMaster.PillTypes;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<PlumbingPillPressComponent, PlumbingDeviceUpdateEvent>(OnDeviceUpdate);
+        SubscribeLocalEvent<PlumbingPillPressComponent, PlumbingPillPressToggleMessage>(OnToggle);
+        SubscribeLocalEvent<PlumbingPillPressComponent, PlumbingPillPressSetDosageMessage>(OnSetDosage);
+        SubscribeLocalEvent<PlumbingPillPressComponent, PlumbingPillPressSetOutputModeMessage>(OnSetOutputMode);
+        SubscribeLocalEvent<PlumbingPillPressComponent, PlumbingPillPressSetPillTypeMessage>(OnSetPillType);
+        SubscribeLocalEvent<PlumbingPillPressComponent, PlumbingPillPressSetMixingMessage>(OnSetMixing);
+        SubscribeLocalEvent<PlumbingPillPressComponent, PlumbingPillPressSetInletRatioMessage>(OnSetInletRatio);
+        SubscribeLocalEvent<PlumbingPillPressComponent, BoundUIOpenedEvent>(OnUIOpened);
+    }
+
+    private void OnDeviceUpdate(Entity<PlumbingPillPressComponent> ent, ref PlumbingDeviceUpdateEvent args)
+    {
+        if (!ent.Comp.Enabled)
+        {
+            _appearance.SetData(ent.Owner, PlumbingVisuals.Running, false);
+            return;
+        }
+
+        if (ent.Comp.MixingEnabled)
+            HandleMixingPull(ent);
+
+        // Pulling from the normal N inlet is handled by PlumbingInletSystem via PlumbingInletComponent.
+        if (!_solutionSystem.TryGetSolution(ent.Owner, ent.Comp.BufferSolutionName, out var solutionEnt, out var solution))
+            return;
+
+        var dosage = FixedPoint2.New(ent.Comp.Dosage);
+        var produced = false;
+
+        if (solution.Volume >= dosage)
+        {
+            // Spawn on the same tile, offset slightly south
+            var spawnCoords = Transform(ent.Owner).Coordinates.Offset(new Vector2(0, -0.3f));
+
+            if (GetOutputEntityCount(spawnCoords) >= MaxOutputEntitiesOnTile)
+            {
+                _appearance.SetData(ent.Owner, PlumbingVisuals.Running, false);
+                UpdateUiState(ent);
+                return;
+            }
+
+            var withdrawal = _solutionSystem.SplitSolution(solutionEnt.Value, dosage);
+
+            if (withdrawal.Volume <= FixedPoint2.Zero)
+            {
+                _appearance.SetData(ent.Owner, PlumbingVisuals.Running, false);
+                UpdateUiState(ent);
+                return;
+            }
+
+            produced = true;
+
+            if (ent.Comp.OutputMode == PillPressOutputMode.Pill)
+            {
+                var item = Spawn(PillPrototypeId, spawnCoords);
+                _solutionSystem.EnsureSolutionEntity(item,
+                    SharedChemMaster.PillSolutionName,
+                    out var itemSolution,
+                    dosage);
+
+                if (itemSolution.HasValue)
+                    _solutionSystem.TryAddSolution(itemSolution.Value, withdrawal);
+
+                var pill = Comp<PillComponent>(item);
+                pill.PillType = ent.Comp.PillType;
+                Dirty(item, pill);
+            }
+            else
+            {
+                var item = Spawn(PatchPrototypeId, spawnCoords);
+
+                _solutionSystem.EnsureSolutionEntity(item,
+                    SharedChemMaster.PatchSolutionName,
+                    out var itemSolution,
+                    dosage);
+
+                if (itemSolution.HasValue)
+                    _solutionSystem.TryAddSolution(itemSolution.Value, withdrawal);
+            }
+        }
+
+        _appearance.SetData(ent.Owner, PlumbingVisuals.Running, produced || solution.Volume >= dosage);
+
+        UpdateUiState(ent);
+    }
+
+    /// <summary>
+    ///     Handles the mixing mode: pulls from E/W inlets into staging solutions at set ratios,
+    ///     then combines into the main buffer when both targets are met.
+    /// </summary>
+    private void HandleMixingPull(Entity<PlumbingPillPressComponent> ent)
+    {
+        var totalRatio = ent.Comp.InletRatioEast + ent.Comp.InletRatioWest;
+        if (totalRatio <= 0)
+            return;
+
+        if (!_solutionSystem.TryGetSolution(ent.Owner, ent.Comp.BufferSolutionName, out var bufferEnt, out var buffer))
+            return;
+
+        // Don't pull more if buffer already has enough for a pill
+        var dosage = FixedPoint2.New(ent.Comp.Dosage);
+        if (buffer.Volume >= dosage)
+            return;
+
+        var eastFraction = ent.Comp.InletRatioEast / totalRatio;
+        var eastTarget = FixedPoint2.New((int) MathF.Round(eastFraction * (float) dosage));
+        var westTarget = dosage - eastTarget; // Remainder goes to west to avoid rounding loss
+
+        if (!_solutionSystem.TryGetSolution(ent.Owner, ent.Comp.StagingEastSolutionName, out var stagingEastEnt, out var stagingEast))
+            return;
+
+        if (!_solutionSystem.TryGetSolution(ent.Owner, ent.Comp.StagingWestSolutionName, out var stagingWestEnt, out var stagingWest))
+            return;
+
+        if (!TryComp<NodeContainerComponent>(ent.Owner, out var nodeContainer))
+            return;
+
+        if (ent.Comp.InletRatioEast > 0 && stagingEast.Volume < eastTarget)
+        {
+            if (nodeContainer.Nodes.TryGetValue(ent.Comp.InletEastNodeName, out var eastNode)
+                && eastNode is PlumbingNode eastPlumbingNode
+                && eastPlumbingNode.PlumbingNet != null)
+            {
+                var eastNeeded = eastTarget - stagingEast.Volume;
+                _pullSystem.PullFromNetwork(ent.Owner, eastPlumbingNode.PlumbingNet, stagingEastEnt.Value, eastNeeded, 0);
+            }
+        }
+
+        if (ent.Comp.InletRatioWest > 0 && stagingWest.Volume < westTarget)
+        {
+            if (nodeContainer.Nodes.TryGetValue(ent.Comp.InletWestNodeName, out var westNode)
+                && westNode is PlumbingNode westPlumbingNode
+                && westPlumbingNode.PlumbingNet != null)
+            {
+                var westNeeded = westTarget - stagingWest.Volume;
+                _pullSystem.PullFromNetwork(ent.Owner, westPlumbingNode.PlumbingNet, stagingWestEnt.Value, westNeeded, 0);
+            }
+        }
+
+        var eastMet = ent.Comp.InletRatioEast <= 0 || stagingEast.Volume >= eastTarget;
+        var westMet = ent.Comp.InletRatioWest <= 0 || stagingWest.Volume >= westTarget;
+
+        if (!eastMet || !westMet)
+            return;
+
+        if (stagingEast.Volume > 0)
+        {
+            var eastWithdrawal = _solutionSystem.SplitSolution(stagingEastEnt.Value, stagingEast.Volume);
+            _solutionSystem.TryAddSolution(bufferEnt.Value, eastWithdrawal);
+        }
+
+        if (stagingWest.Volume > 0)
+        {
+            var westWithdrawal = _solutionSystem.SplitSolution(stagingWestEnt.Value, stagingWest.Volume);
+            _solutionSystem.TryAddSolution(bufferEnt.Value, westWithdrawal);
+        }
+    }
+
+    private void OnToggle(Entity<PlumbingPillPressComponent> ent, ref PlumbingPillPressToggleMessage args)
+    {
+        ent.Comp.Enabled = args.Enabled;
+        DirtyField(ent, ent.Comp, nameof(PlumbingPillPressComponent.Enabled));
+        ClickSound(ent);
+        UpdateUiState(ent);
+    }
+
+    private void OnSetDosage(Entity<PlumbingPillPressComponent> ent, ref PlumbingPillPressSetDosageMessage args)
+    {
+        var dosage = Math.Clamp(args.Dosage, MinDosage, MaxDosage);
+        ent.Comp.Dosage = dosage;
+        DirtyField(ent, ent.Comp, nameof(PlumbingPillPressComponent.Dosage));
+        ClickSound(ent);
+        UpdateUiState(ent);
+    }
+
+    private void OnSetOutputMode(Entity<PlumbingPillPressComponent> ent, ref PlumbingPillPressSetOutputModeMessage args)
+    {
+        ent.Comp.OutputMode = args.OutputMode;
+        DirtyField(ent, ent.Comp, nameof(PlumbingPillPressComponent.OutputMode));
+        ClickSound(ent);
+        UpdateUiState(ent);
+    }
+
+    private void OnSetPillType(Entity<PlumbingPillPressComponent> ent, ref PlumbingPillPressSetPillTypeMessage args)
+    {
+        if (args.PillType >= MaxPillTypes)
+            return;
+
+        ent.Comp.PillType = args.PillType;
+        DirtyField(ent, ent.Comp, nameof(PlumbingPillPressComponent.PillType));
+        ClickSound(ent);
+        UpdateUiState(ent);
+    }
+
+    private void OnSetMixing(Entity<PlumbingPillPressComponent> ent, ref PlumbingPillPressSetMixingMessage args)
+    {
+        ent.Comp.MixingEnabled = args.MixingEnabled;
+        DirtyField(ent, ent.Comp, nameof(PlumbingPillPressComponent.MixingEnabled));
+        ClickSound(ent);
+        UpdateUiState(ent);
+    }
+
+    private void OnSetInletRatio(Entity<PlumbingPillPressComponent> ent, ref PlumbingPillPressSetInletRatioMessage args)
+    {
+        var ratio = Math.Clamp(args.Ratio, 0f, 100f);
+        var complement = 100f - ratio;
+
+        switch (args.Inlet)
+        {
+            case PillPressInlet.East:
+                ent.Comp.InletRatioEast = ratio;
+                ent.Comp.InletRatioWest = complement;
+                break;
+            case PillPressInlet.West:
+                ent.Comp.InletRatioWest = ratio;
+                ent.Comp.InletRatioEast = complement;
+                break;
+            default:
+                return;
+        }
+
+        DirtyField(ent, ent.Comp, nameof(PlumbingPillPressComponent.InletRatioEast));
+        DirtyField(ent, ent.Comp, nameof(PlumbingPillPressComponent.InletRatioWest));
+
+        ClickSound(ent);
+        UpdateUiState(ent);
+    }
+
+    private void OnUIOpened(Entity<PlumbingPillPressComponent> ent, ref BoundUIOpenedEvent args)
+    {
+        UpdateUiState(ent);
+    }
+
+    private void UpdateUiState(Entity<PlumbingPillPressComponent> ent)
+    {
+        var bufferVolume = FixedPoint2.Zero;
+
+        if (_solutionSystem.TryGetSolution(ent.Owner, ent.Comp.BufferSolutionName, out _, out var solution))
+        {
+            bufferVolume = solution.Volume;
+        }
+
+        var stagingEastVolume = FixedPoint2.Zero;
+        var stagingWestVolume = FixedPoint2.Zero;
+
+        if (_solutionSystem.TryGetSolution(ent.Owner, ent.Comp.StagingEastSolutionName, out _, out var stagingEast))
+            stagingEastVolume = stagingEast.Volume;
+
+        if (_solutionSystem.TryGetSolution(ent.Owner, ent.Comp.StagingWestSolutionName, out _, out var stagingWest))
+            stagingWestVolume = stagingWest.Volume;
+
+        var state = new PlumbingPillPressBoundUserInterfaceState(
+            bufferVolume,
+            ent.Comp.Dosage,
+            ent.Comp.OutputMode,
+            ent.Comp.PillType,
+            ent.Comp.Enabled,
+            ent.Comp.MixingEnabled,
+            ent.Comp.InletRatioEast,
+            ent.Comp.InletRatioWest,
+            stagingEastVolume,
+            stagingWestVolume);
+
+        _ui.SetUiState(ent.Owner, PlumbingPillPressUiKey.Key, state);
+    }
+
+    private void ClickSound(EntityUid uid)
+    {
+        if (TryComp<PlumbingDeviceComponent>(uid, out var device))
+            _audio.PlayPvs(device.ClickSound, uid, AudioParams.Default.WithVolume(-2f));
+    }
+
+    private int GetOutputEntityCount(EntityCoordinates coords)
+    {
+        var count = 0;
+
+        foreach (var entity in _lookup.GetEntitiesIntersecting(coords))
+        {
+            if (HasComp<PillComponent>(entity) || HasComp<PatchComponent>(entity))
+                count++;
+        }
+
+        return count;
+    }
+}
diff --git a/Content.Server/_Starlight/Plumbing/EntitySystems/PlumbingPullSystem.cs b/Content.Server/_Starlight/Plumbing/EntitySystems/PlumbingPullSystem.cs
new file mode 100644
index 00000000000..57cb16bd6c3
--- /dev/null
+++ b/Content.Server/_Starlight/Plumbing/EntitySystems/PlumbingPullSystem.cs
@@ -0,0 +1,317 @@
+using Content.Server._Starlight.Plumbing.NodeGroups;
+using Content.Server._Starlight.Plumbing.Nodes;
+using Content.Shared._Starlight.Plumbing.Components;
+using Content.Shared.Chemistry.Components;
+using Content.Shared.Chemistry.EntitySystems;
+using Content.Shared.Chemistry.Reagent;
+using Content.Shared.Containers.ItemSlots;
+using Content.Shared.FixedPoint;
+using JetBrains.Annotations;
+
+namespace Content.Server._Starlight.Plumbing.EntitySystems;
+
+/// <summary>
+///     Provides methods for pulling reagents from plumbing networks.
+///     All plumbing machines should use this system to pull from outlets on the network attached to their inlet.
+///     Raises <see cref="PlumbingPullAttemptEvent"/> before each reagent pull, allowing other
+///     systems (like filters) to deny specific reagents.
+///     Machines try to pull from each outlet in their network using a "round-robin" style approach
+///     to ensure fair distribution when multiple sources are available.
+///     Supports outlets with valves (Enabled flag) and indirect solution lookup via container slots
+///     (e.g., pulling from a beaker inside a dispenser).
+/// </summary>
+[UsedImplicitly]
+public sealed class PlumbingPullSystem : EntitySystem
+{
+    [Dependency] private readonly SharedSolutionContainerSystem _solutionSystem = default!;
+    [Dependency] private readonly ItemSlotsSystem _itemSlots = default!;
+
+    private EntityQuery<PlumbingOutletComponent> _outletQuery;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+        _outletQuery = GetEntityQuery<PlumbingOutletComponent>();
+    }
+
+    /// <summary>
+    ///     Pulls all allowed reagents from outlets on a plumbing network into a destination solution.
+    /// </summary>
+    /// <param name="puller">The entity doing the pulling.</param>
+    /// <param name="network">The plumbing network to pull from.</param>
+    /// <param name="destination">The solution to add pulled reagents to.</param>
+    /// <param name="maxAmount">Maximum amount to pull total.</param>
+    /// <param name="roundRobinIndex">
+    ///     Index tracking which outlet to start from. The returned NextIndex should be
+    ///     stored for the next call to cycle through outlets fairly. Initialize to 0.
+    /// </param>
+    /// <returns>Tuple of (amount pulled, next round-robin index to use).</returns>
+    public (FixedPoint2 Pulled, int NextIndex) PullFromNetwork(
+        EntityUid puller,
+        IPlumbingNet network,
+        Entity<SolutionComponent> destination,
+        FixedPoint2 maxAmount,
+        int roundRobinIndex)
+    {
+        var availableVolume = destination.Comp.Solution.AvailableVolume;
+        var remaining = FixedPoint2.Min(maxAmount, availableVolume);
+        if (remaining <= 0)
+            return (FixedPoint2.Zero, roundRobinIndex);
+
+        // Build list of valid outlets to pull from
+        var outlets = new List<(PlumbingNode Node, PlumbingOutletComponent Outlet)>();
+        foreach (var node in network.Nodes)
+        {
+            if (node is not PlumbingNode plumbingNode || plumbingNode.Owner == puller)
+                continue;
+
+            if (!_outletQuery.TryGetComponent(plumbingNode.Owner, out var outlet))
+                continue;
+
+            if (!outlet.Enabled)
+                continue;
+
+            var isOutletNode = false;
+            foreach (var name in outlet.OutletNames)
+            {
+                if (plumbingNode.Name.Equals(name, StringComparison.OrdinalIgnoreCase))
+                {
+                    isOutletNode = true;
+                    break;
+                }
+            }
+            if (!isOutletNode)
+                continue;
+
+            outlets.Add((plumbingNode, outlet));
+        }
+
+        if (outlets.Count == 0)
+            return (FixedPoint2.Zero, roundRobinIndex);
+
+        // Round-robin: start from the saved index, wrap around
+        // This ensures each outlet gets a fair chance to be pulled from first
+        var startIndex = roundRobinIndex % outlets.Count;
+
+        var totalPulled = FixedPoint2.Zero;
+
+        for (var i = 0; i < outlets.Count && remaining > 0; i++)
+        {
+            var index = (startIndex + i) % outlets.Count;
+            var (plumbingNode, outlet) = outlets[index];
+
+            var pulled = PullFromOutlet(puller, plumbingNode.Owner, plumbingNode.Name, outlet, destination, remaining);
+            totalPulled += pulled;
+            remaining -= pulled;
+        }
+
+        var nextIndex = (startIndex + 1) % outlets.Count;
+        return (totalPulled, nextIndex);
+    }
+
+    /// <summary>
+    ///     Pulls specific reagents from outlets on a plumbing network sequentially.
+    ///     Used by the plumbing reactor to pull in its targeted reagents.
+    /// </summary>
+    /// <param name="puller">The entity doing the pulling.</param>
+    /// <param name="network">The plumbing network to pull from.</param>
+    /// <param name="destination">The solution to add pulled reagents to.</param>
+    /// <param name="reagentTargets">Map of reagent ID to amount still needed.</param>
+    /// <param name="transferLimit">Maximum total amount to transfer per update.</param>
+    /// <returns>Map of reagent ID to amount actually pulled.</returns>
+    public Dictionary<string, FixedPoint2> PullSpecificReagents(
+        EntityUid puller,
+        IPlumbingNet network,
+        Entity<SolutionComponent> destination,
+        Dictionary<string, FixedPoint2> reagentTargets,
+        FixedPoint2 transferLimit)
+    {
+        var pulled = new Dictionary<string, FixedPoint2>();
+        var destSolution = destination.Comp.Solution;
+        var availableVolume = destSolution.AvailableVolume;
+        var remaining = FixedPoint2.Min(transferLimit, availableVolume);
+
+        if (remaining <= 0)
+            return pulled;
+
+        // Sequential pulling: fill each reagent fully before moving to the next
+        foreach (var (reagentId, neededAmount) in reagentTargets)
+        {
+            if (remaining <= 0)
+                break;
+
+            if (neededAmount <= 0)
+                continue;
+
+            var stillNeeded = neededAmount;
+
+            // Try to pull this reagent from all available outlets
+            foreach (var node in network.Nodes)
+            {
+                if (remaining <= 0 || stillNeeded <= 0)
+                    break;
+
+                if (node is not PlumbingNode plumbingNode || plumbingNode.Owner == puller)
+                    continue;
+
+                if (!_outletQuery.TryGetComponent(plumbingNode.Owner, out var outlet))
+                    continue;
+
+                if (!outlet.Enabled)
+                    continue;
+
+                var isOutletNode = false;
+                foreach (var name in outlet.OutletNames)
+                {
+                    if (plumbingNode.Name.Equals(name, StringComparison.OrdinalIgnoreCase))
+                    {
+                        isOutletNode = true;
+                        break;
+                    }
+                }
+                if (!isOutletNode)
+                    continue;
+
+                if (GetOutletSolution(plumbingNode.Owner, outlet) is not { } sourceSoln)
+                    continue;
+
+                var available = sourceSoln.Comp.Solution.GetReagentQuantity(new ReagentId(reagentId, null));
+                if (available <= 0)
+                    continue;
+
+                var attemptEv = new PlumbingPullAttemptEvent(puller, plumbingNode.Name, reagentId);
+                RaiseLocalEvent(plumbingNode.Owner, ref attemptEv);
+
+                if (attemptEv.Cancelled)
+                    continue;
+
+                var toPull = FixedPoint2.Min(available, stillNeeded);
+                toPull = FixedPoint2.Min(toPull, remaining);
+
+                var actualPulled = _solutionSystem.RemoveReagent(sourceSoln, new ReagentId(reagentId, null), toPull);
+                if (actualPulled > 0)
+                {
+                    _solutionSystem.TryAddReagent(destination, new ReagentId(reagentId, null), actualPulled, out var actuallyAdded);
+
+                    // Return any excess to source to prevent loss
+                    var excess = actualPulled - actuallyAdded;
+                    if (excess > 0)
+                        _solutionSystem.TryAddReagent(sourceSoln, new ReagentId(reagentId, null), excess, out _);
+
+                    pulled[reagentId] = pulled.GetValueOrDefault(reagentId, FixedPoint2.Zero) + actuallyAdded;
+                    stillNeeded -= actuallyAdded;
+                    remaining -= actuallyAdded;
+                }
+            }
+        }
+
+        return pulled;
+    }
+
+    /// <summary>
+    ///     Pulls allowed reagents from a specific outlet into a destination solution.
+    /// </summary>
+    private FixedPoint2 PullFromOutlet(
+        EntityUid puller,
+        EntityUid sourceOwner,
+        string nodeName,
+        PlumbingOutletComponent outlet,
+        Entity<SolutionComponent> destination,
+        FixedPoint2 maxAmount)
+    {
+        if (GetOutletSolution(sourceOwner, outlet) is not { } sourceSoln)
+            return FixedPoint2.Zero;
+
+        var sourceSolution = sourceSoln.Comp.Solution;
+        if (sourceSolution.Volume <= 0)
+            return FixedPoint2.Zero;
+
+        var destSolution = destination.Comp.Solution;
+        var availableSpace = destSolution.AvailableVolume;
+        if (availableSpace <= 0)
+            return FixedPoint2.Zero;
+
+        var remaining = FixedPoint2.Min(maxAmount, availableSpace);
+
+        // Build snapshot of allowed reagents to avoid modifying collection during iteration
+        var allowedReagents = new List<(ReagentId Reagent, FixedPoint2 Quantity)>();
+
+        foreach (var reagent in sourceSolution.Contents)
+        {
+            var attemptEv = new PlumbingPullAttemptEvent(puller, nodeName, reagent.Reagent.Prototype);
+            RaiseLocalEvent(sourceOwner, ref attemptEv);
+
+            if (!attemptEv.Cancelled)
+                allowedReagents.Add((reagent.Reagent, reagent.Quantity));
+        }
+
+        if (allowedReagents.Count == 0)
+            return FixedPoint2.Zero;
+
+        var totalPulled = FixedPoint2.Zero;
+
+        foreach (var (reagent, quantity) in allowedReagents)
+        {
+            if (remaining <= 0)
+                break;
+
+            var toPull = FixedPoint2.Min(quantity, remaining);
+            if (toPull <= 0)
+                continue;
+
+            // Raise destination-side event — allows the puller to cap or deny the pull
+            var intoEv = new PlumbingPullIntoAttemptEvent(sourceOwner, reagent.Prototype, toPull);
+            RaiseLocalEvent(puller, ref intoEv);
+
+            if (intoEv.Cancelled)
+                continue;
+
+            toPull = FixedPoint2.Min(toPull, intoEv.MaxAllowed);
+            if (toPull <= 0)
+                continue;
+
+            var pulled = _solutionSystem.RemoveReagent(sourceSoln, reagent, toPull);
+            if (pulled > 0)
+            {
+                _solutionSystem.TryAddReagent(destination, reagent, pulled, out var actuallyAdded);
+
+                // Return any excess to source to prevent loss
+                var excess = pulled - actuallyAdded;
+                if (excess > 0)
+                    _solutionSystem.TryAddReagent(sourceSoln, reagent, excess, out _);
+
+                totalPulled += actuallyAdded;
+                remaining -= actuallyAdded;
+            }
+        }
+
+        return totalPulled;
+    }
+
+    /// <summary>
+    ///     Gets the solution entity to pull from for an outlet, handling pulling from beakers in container slots.
+    ///     If ContainerSlotId is set, gets the solution from the entity in that item slot.
+    ///     Otherwise, gets the solution directly from the outlet entity.
+    /// </summary>
+    /// <returns>The solution entity, or null if not found.</returns>
+    private Entity<SolutionComponent>? GetOutletSolution(EntityUid outletOwner, PlumbingOutletComponent outlet)
+    {
+        EntityUid targetEntity;
+
+        if (outlet.ContainerSlotId != null)
+        {
+            var containerEntity = _itemSlots.GetItemOrNull(outletOwner, outlet.ContainerSlotId);
+            if (containerEntity == null)
+                return null;
+            targetEntity = containerEntity.Value;
+        }
+        else
+        {
+            targetEntity = outletOwner;
+        }
+
+        return _solutionSystem.TryGetSolution(targetEntity, outlet.SolutionName, out var solutionEnt, out _)
+            ? solutionEnt
+            : null;
+    }
+}
diff --git a/Content.Server/_Starlight/Plumbing/EntitySystems/PlumbingReactorSystem.cs b/Content.Server/_Starlight/Plumbing/EntitySystems/PlumbingReactorSystem.cs
new file mode 100644
index 00000000000..db9bad9f121
--- /dev/null
+++ b/Content.Server/_Starlight/Plumbing/EntitySystems/PlumbingReactorSystem.cs
@@ -0,0 +1,326 @@
+using Content.Server._Starlight.Plumbing.Components;
+using Content.Server._Starlight.Plumbing.Nodes;
+using Content.Server.NodeContainer.EntitySystems;
+using Content.Server.Popups;
+using Content.Server.Power.EntitySystems;
+using Content.Server.UserInterface;
+using Content.Shared._Starlight.Plumbing;
+using Content.Shared._Starlight.Plumbing.Components;
+using Content.Shared.Atmos;
+using Content.Shared.Chemistry;
+using Content.Shared.Chemistry.Components;
+using Content.Shared.Chemistry.EntitySystems;
+using Content.Shared.Chemistry.Reaction;
+using Content.Shared.Chemistry.Reagent;
+using Content.Shared.FixedPoint;
+using Content.Shared.Power;
+using JetBrains.Annotations;
+using Robust.Server.GameObjects;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
+using Robust.Shared.Prototypes;
+using SharedAppearanceSystem = Robust.Shared.GameObjects.SharedAppearanceSystem;
+
+namespace Content.Server._Starlight.Plumbing.EntitySystems;
+
+/// <summary>
+///     Handles plumbing reactor machine behavior: reactor pulls reagents into a buffer until they reach
+///     target quantities, and then fully reacts the buffer and moves products to output container.
+/// </summary>
+[UsedImplicitly]
+public sealed class PlumbingReactorSystem : EntitySystem
+{
+    [Dependency] private readonly SharedSolutionContainerSystem _solutionSystem = default!;
+    [Dependency] private readonly ChemicalReactionSystem _reactionSystem = default!;
+    [Dependency] private readonly UserInterfaceSystem _ui = default!;
+    [Dependency] private readonly NodeContainerSystem _nodeContainer = default!;
+    [Dependency] private readonly PopupSystem _popup = default!;
+    [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
+    [Dependency] private readonly PlumbingPullSystem _pullSystem = default!;
+    [Dependency] private readonly PowerReceiverSystem _power = default!;
+    [Dependency] private readonly SharedAppearanceSystem _appearance = default!;
+    [Dependency] private readonly SharedAudioSystem _audio = default!;
+
+    /// <summary>
+    ///     Temperature tolerance for considering target reached (in Kelvin).
+    /// </summary>
+    private const float TemperatureTolerance = 0.5f;
+
+    /// <summary>
+    ///     Minimum allowed target temperature (cosmic microwave background).
+    /// </summary>
+    private const float MinTemperature = Atmospherics.TCMB;
+
+    /// <summary>
+    ///     Maximum allowed target temperature.
+    /// </summary>
+    private const float MaxTemperature = 1000f;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<PlumbingReactorComponent, PlumbingDeviceUpdateEvent>(OnReactorUpdate);
+        SubscribeLocalEvent<PlumbingReactorComponent, PlumbingReactorToggleMessage>(OnToggle);
+        SubscribeLocalEvent<PlumbingReactorComponent, PlumbingReactorSetTargetMessage>(OnSetTarget);
+        SubscribeLocalEvent<PlumbingReactorComponent, PlumbingReactorRemoveTargetMessage>(OnRemoveTarget);
+        SubscribeLocalEvent<PlumbingReactorComponent, PlumbingReactorClearTargetsMessage>(OnClearTargets);
+        SubscribeLocalEvent<PlumbingReactorComponent, PlumbingReactorSetTemperatureMessage>(OnSetTemperature);
+        SubscribeLocalEvent<PlumbingReactorComponent, BoundUIOpenedEvent>(OnUIOpened);
+    }
+
+    private void OnReactorUpdate(Entity<PlumbingReactorComponent> ent, ref PlumbingDeviceUpdateEvent args)
+    {
+        if (!ent.Comp.Enabled)
+            return;
+
+        if (!_solutionSystem.TryGetSolution(ent.Owner, ent.Comp.BufferSolutionName, out var bufferEnt, out var buffer))
+            return;
+
+        if (!_solutionSystem.TryGetSolution(ent.Owner, ent.Comp.OutputSolutionName, out var outputEnt, out var output))
+            return;
+
+        if (output.AvailableVolume <= 0)
+        {
+            UpdateUI(ent);
+            return;
+        }
+
+        if (ent.Comp.ReagentTargets.Count == 0)
+        {
+            UpdateUI(ent);
+            return;
+        }
+
+        if (!_nodeContainer.TryGetNode<PlumbingNode>(ent.Owner, ent.Comp.InletName, out var inletNode))
+            return;
+
+        if (inletNode.PlumbingNet == null)
+            return;
+
+        var neededTargets = new Dictionary<string, FixedPoint2>();
+        var allMet = true;
+
+        foreach (var (reagentProtoId, targetAmount) in ent.Comp.ReagentTargets)
+        {
+            var reagentId = reagentProtoId.Id;
+            var currentAmount = buffer.GetReagentQuantity(new ReagentId(reagentId, null));
+            var needed = targetAmount - currentAmount;
+            if (needed > 0)
+            {
+                allMet = false;
+                neededTargets[reagentId] = needed;
+            }
+        }
+
+        if (neededTargets.Count > 0)
+            _appearance.SetData(ent.Owner, PlumbingVisuals.Running, true);
+
+        if (neededTargets.Count > 0)
+            _pullSystem.PullSpecificReagents(ent.Owner, inletNode.PlumbingNet, bufferEnt.Value, neededTargets, ent.Comp.TransferAmount);
+
+        if (allMet)
+        {
+            // Start heating only once reagents are ready
+            if (_power.IsPowered(ent.Owner))
+            {
+                ApplyTemperatureControl(ent, bufferEnt.Value, buffer, args.dt);
+            }
+
+            // Dont do the reaction until we reach the the target temperature or close enough, but update the ui.
+            if (!MathHelper.CloseTo(buffer.Temperature, ent.Comp.TargetTemperature, TemperatureTolerance))
+            {
+                UpdateUI(ent);
+                return;
+            }
+
+            var reactionOccurred = _reactionSystem.FullyReactSolution(bufferEnt.Value);
+
+            var products = new List<(ReagentId Reagent, FixedPoint2 Quantity)>();
+            foreach (var reagent in buffer.Contents)
+            {
+                // Skip target reagents still in the input buffer and only move products
+                if (ent.Comp.ReagentTargets.ContainsKey(new ProtoId<ReagentPrototype>(reagent.Reagent.Prototype)))
+                    continue;
+
+                products.Add((reagent.Reagent, reagent.Quantity));
+            }
+
+            if (products.Count > 0)
+            {
+                foreach (var (reagent, quantity) in products)
+                {
+                    var removed = _solutionSystem.RemoveReagent(bufferEnt.Value, reagent, quantity);
+                    if (removed > 0)
+                        _solutionSystem.TryAddReagent(outputEnt.Value, reagent, removed, out _);
+                }
+            }
+
+            if (reactionOccurred)
+            {
+                // Reset buffer to ambient temperature after any completed reaction pass.
+                _solutionSystem.SetTemperature(bufferEnt.Value, Atmospherics.T20C);
+                _appearance.SetData(ent.Owner, PlumbingVisuals.Running, false);
+            }
+        }
+
+        UpdateUI(ent);
+    }
+
+    /// <summary>
+    ///     Applies temperature control by adding thermal energy to reach target temperature. Adds negative thermal energy for cooling.
+    /// </summary>
+    private void ApplyTemperatureControl(
+        Entity<PlumbingReactorComponent> ent,
+        Entity<SolutionComponent> solutionEnt,
+        Solution solution,
+        float dt)
+    {
+        var currentTemp = solution.Temperature;
+        var targetTemp = ent.Comp.TargetTemperature;
+
+        if (MathHelper.CloseTo(currentTemp, targetTemp, TemperatureTolerance))
+            return;
+
+        var heatCap = solution.GetHeatCapacity(_prototypeManager);
+        if (heatCap <= 0f)
+            return; // Don't heat empty solution
+
+        // Calculate max energy we can transfer this tick in joules, watts * seconds = joules
+        var maxEnergyTransfer = ent.Comp.HeatTransferPower * dt;
+
+        var tempDiff = targetTemp - currentTemp;
+        var energyNeeded = tempDiff * heatCap;
+
+        var energyTransfer = Math.Clamp(energyNeeded, -maxEnergyTransfer, maxEnergyTransfer);
+
+        _solutionSystem.AddThermalEnergy(solutionEnt, energyTransfer);
+    }
+
+    private void OnToggle(Entity<PlumbingReactorComponent> ent, ref PlumbingReactorToggleMessage args)
+    {
+        ent.Comp.Enabled = args.Enabled;
+        DirtyField(ent, ent.Comp, nameof(PlumbingReactorComponent.Enabled));
+        ClickSound(ent.Owner);
+        UpdateUI(ent);
+
+        if (!args.Enabled)
+            _appearance.SetData(ent.Owner, PlumbingVisuals.Running, false);
+    }
+
+    private void OnSetTarget(Entity<PlumbingReactorComponent> ent, ref PlumbingReactorSetTargetMessage args)
+    {
+        if (args.Quantity <= 0)
+        {
+            if (_prototypeManager.HasIndex<ReagentPrototype>(args.ReagentId))
+                ent.Comp.ReagentTargets.Remove(new ProtoId<ReagentPrototype>(args.ReagentId));
+            DirtyField(ent, ent.Comp, nameof(PlumbingReactorComponent.ReagentTargets));
+            UpdateUI(ent);
+            return;
+        }
+
+        if (!_prototypeManager.HasIndex<ReagentPrototype>(args.ReagentId))
+        {
+            _popup.PopupEntity(Loc.GetString("plumbing-reactor-invalid-reagent", ("reagent", args.ReagentId)), ent.Owner, args.Actor);
+            return;
+        }
+
+        // Clamp target quantity to remaining buffer capacity (max volume minus other targets)
+        var clampedQuantity = args.Quantity;
+        if (_solutionSystem.TryGetSolution(ent.Owner, ent.Comp.BufferSolutionName, out _, out var buffer))
+        {
+            var otherTargetsTotal = FixedPoint2.Zero;
+            var key = new ProtoId<ReagentPrototype>(args.ReagentId);
+            foreach (var (protoId, quantity) in ent.Comp.ReagentTargets)
+            {
+                if (protoId != key)
+                    otherTargetsTotal += quantity;
+            }
+
+            var remaining = FixedPoint2.Max(buffer.MaxVolume - otherTargetsTotal, FixedPoint2.Zero);
+            clampedQuantity = FixedPoint2.Min(clampedQuantity, remaining);
+        }
+
+        ent.Comp.ReagentTargets[new ProtoId<ReagentPrototype>(args.ReagentId)] = clampedQuantity;
+        DirtyField(ent, ent.Comp, nameof(PlumbingReactorComponent.ReagentTargets));
+        ClickSound(ent.Owner);
+        UpdateUI(ent);
+    }
+
+    private void OnRemoveTarget(Entity<PlumbingReactorComponent> ent, ref PlumbingReactorRemoveTargetMessage args)
+    {
+        ent.Comp.ReagentTargets.Remove(new ProtoId<ReagentPrototype>(args.ReagentId));
+        DirtyField(ent, ent.Comp, nameof(PlumbingReactorComponent.ReagentTargets));
+        ClickSound(ent.Owner);
+        UpdateUI(ent);
+    }
+
+    private void OnClearTargets(Entity<PlumbingReactorComponent> ent, ref PlumbingReactorClearTargetsMessage args)
+    {
+        ent.Comp.ReagentTargets.Clear();
+        DirtyField(ent, ent.Comp, nameof(PlumbingReactorComponent.ReagentTargets));
+        ClickSound(ent.Owner);
+        UpdateUI(ent);
+    }
+
+    private void OnSetTemperature(Entity<PlumbingReactorComponent> ent, ref PlumbingReactorSetTemperatureMessage args)
+    {
+        // Clamp to reasonable values 
+        ent.Comp.TargetTemperature = Math.Clamp(args.Temperature, MinTemperature, MaxTemperature);
+        DirtyField(ent, ent.Comp, nameof(PlumbingReactorComponent.TargetTemperature));
+        ClickSound(ent.Owner);
+        UpdateUI(ent);
+    }
+
+    private void OnUIOpened(Entity<PlumbingReactorComponent> ent, ref BoundUIOpenedEvent args)
+    {
+        UpdateUI(ent);
+    }
+
+    private void UpdateUI(Entity<PlumbingReactorComponent> ent)
+    {
+        var bufferContents = new Dictionary<string, FixedPoint2>();
+        var outputContents = new Dictionary<string, FixedPoint2>();
+        var currentTemperature = Atmospherics.T20C;
+
+        if (_solutionSystem.TryGetSolution(ent.Owner, ent.Comp.BufferSolutionName, out _, out var buffer))
+        {
+            foreach (var reagent in buffer.Contents)
+            {
+                bufferContents[reagent.Reagent.Prototype] = reagent.Quantity;
+            }
+            currentTemperature = buffer.Temperature;
+        }
+
+        if (_solutionSystem.TryGetSolution(ent.Owner, ent.Comp.OutputSolutionName, out _, out var output))
+        {
+            foreach (var reagent in output.Contents)
+            {
+                outputContents[reagent.Reagent.Prototype] = reagent.Quantity;
+            }
+        }
+
+        var reagentTargets = new Dictionary<string, FixedPoint2>();
+        foreach (var (protoId, quantity) in ent.Comp.ReagentTargets)
+        {
+            reagentTargets[protoId.Id] = quantity;
+        }
+
+        var state = new PlumbingReactorBoundUserInterfaceState(
+            reagentTargets,
+            bufferContents,
+            outputContents,
+            ent.Comp.Enabled,
+            ent.Comp.TargetTemperature,
+            currentTemperature
+        );
+
+        _ui.SetUiState(ent.Owner, PlumbingReactorUiKey.Key, state);
+    }
+
+    private void ClickSound(EntityUid uid)
+    {
+        if (TryComp<PlumbingDeviceComponent>(uid, out var device))
+            _audio.PlayPvs(device.ClickSound, uid, AudioParams.Default.WithVolume(-2f));
+    }
+}
diff --git a/Content.Server/_Starlight/Plumbing/EntitySystems/PlumbingSmartDispenserSystem.cs b/Content.Server/_Starlight/Plumbing/EntitySystems/PlumbingSmartDispenserSystem.cs
new file mode 100644
index 00000000000..a2c59f600ad
--- /dev/null
+++ b/Content.Server/_Starlight/Plumbing/EntitySystems/PlumbingSmartDispenserSystem.cs
@@ -0,0 +1,368 @@
+using System.Linq;
+using Content.Server._Starlight.Plumbing.Components;
+using Content.Shared._Starlight.Plumbing;
+using Content.Shared._Starlight.Plumbing.Components;
+using Content.Shared.Chemistry.Components;
+using Content.Shared.Chemistry.EntitySystems;
+using Content.Shared.Chemistry.Reagent;
+using Content.Shared.FixedPoint;
+using Content.Shared.Interaction;
+using Content.Shared.Labels.Components;
+using Content.Shared.Popups;
+using Content.Shared.UserInterface;
+using JetBrains.Annotations;
+using Robust.Server.GameObjects;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Utility;
+
+namespace Content.Server._Starlight.Plumbing.EntitySystems;
+
+/// <summary>
+///     Handles the plumbing smart dispenser: pulls all reagents from the network,
+///     stores up to a per-reagent cap, and fills labeled jugs on interaction.
+/// </summary>
+[UsedImplicitly]
+public sealed class PlumbingSmartDispenserSystem : EntitySystem
+{
+    [Dependency] private readonly SharedSolutionContainerSystem _solutionSystem = default!;
+    [Dependency] private readonly UserInterfaceSystem _uiSystem = default!;
+    [Dependency] private readonly SharedPopupSystem _popup = default!;
+    [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
+
+    /// <summary>
+    /// Cached mapping of label prefix (lowercase) → reagent prototype ID.
+    /// Built lazily on first use and invalidated on prototype reload.
+    /// </summary>
+    private Dictionary<string, string>? _labelCache;
+
+    /// <summary>
+    /// Cached sorted list of all reagent localized names for prefix matching.
+    /// </summary>
+    private List<(string LocalizedName, string PrototypeId)>? _reagentNames;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<PlumbingSmartDispenserComponent, PlumbingDeviceUpdateEvent>(OnDeviceUpdate);
+        SubscribeLocalEvent<PlumbingSmartDispenserComponent, PlumbingPullIntoAttemptEvent>(OnPullInto);
+        SubscribeLocalEvent<PlumbingSmartDispenserComponent, InteractUsingEvent>(OnInteractUsing);
+        SubscribeLocalEvent<PlumbingSmartDispenserComponent, AfterActivatableUIOpenEvent>(OnUIOpened);
+
+        _prototypeManager.PrototypesReloaded += OnPrototypesReloaded;
+    }
+
+    public override void Shutdown()
+    {
+        base.Shutdown();
+        _prototypeManager.PrototypesReloaded -= OnPrototypesReloaded;
+    }
+
+    private void OnPrototypesReloaded(PrototypesReloadedEventArgs args)
+    {
+        // Invalidate cache so it gets rebuilt with new reagent names
+        _labelCache = null;
+        _reagentNames = null;
+    }
+
+    private void OnDeviceUpdate(Entity<PlumbingSmartDispenserComponent> ent, ref PlumbingDeviceUpdateEvent args)
+    {
+        UpdateUiState(ent);
+    }
+
+    /// <summary>
+    /// Caps or denies pulls for reagents that are at or near the per-reagent limit.
+    /// </summary>
+    private void OnPullInto(Entity<PlumbingSmartDispenserComponent> ent, ref PlumbingPullIntoAttemptEvent args)
+    {
+        if (!_solutionSystem.TryGetSolution(ent.Owner, ent.Comp.SolutionName, out _, out var solution))
+            return;
+
+        var current = solution.GetReagentQuantity(new ReagentId(args.ReagentPrototype, null));
+        var room = ent.Comp.MaxPerReagent - current;
+
+        if (room <= FixedPoint2.Zero)
+        {
+            args.Cancelled = true;
+            return;
+        }
+
+        if (room < args.MaxAllowed)
+            args.MaxAllowed = room;
+    }
+
+    private void OnInteractUsing(Entity<PlumbingSmartDispenserComponent> ent, ref InteractUsingEvent args)
+    {
+        if (args.Handled)
+            return;
+
+        if (!TryComp<LabelComponent>(args.Used, out var label) || string.IsNullOrEmpty(label.CurrentLabel))
+        {
+            _popup.PopupEntity(Loc.GetString("plumbing-smart-dispenser-no-label"), ent.Owner, args.User);
+            return;
+        }
+
+        if (!TryMatchLabelToReagent(label.CurrentLabel, out var reagentId))
+        {
+            _popup.PopupEntity(Loc.GetString("plumbing-smart-dispenser-no-match"), ent.Owner, args.User);
+            return;
+        }
+
+        if (!_solutionSystem.TryGetSolution(ent.Owner, ent.Comp.SolutionName, out var fridgeSolnEnt, out var fridgeSolution))
+            return;
+
+        var sourceReagent = fridgeSolution.Contents.FirstOrDefault(r => r.Reagent.Prototype == reagentId);
+        var available = sourceReagent.Quantity;
+
+        if (available <= FixedPoint2.Zero)
+        {
+            _popup.PopupEntity(Loc.GetString("plumbing-smart-dispenser-not-in-stock",
+                ("reagent", _prototypeManager.Index<ReagentPrototype>(reagentId).LocalizedName)),
+                ent.Owner, args.User);
+            return;
+        }
+
+        if (!_solutionSystem.TryGetRefillableSolution(args.Used, out var jugSolnEnt, out var jugSolution))
+            return;
+
+        var jugAvailable = jugSolution.AvailableVolume;
+        if (jugAvailable <= FixedPoint2.Zero)
+        {
+            _popup.PopupEntity(Loc.GetString("plumbing-smart-dispenser-jug-full"), ent.Owner, args.User);
+            return;
+        }
+
+        var transferAmount = FixedPoint2.Min(available, jugAvailable);
+        var removed = _solutionSystem.RemoveReagent(fridgeSolnEnt.Value, sourceReagent.Reagent, transferAmount);
+
+        if (removed > FixedPoint2.Zero)
+        {
+            _solutionSystem.TryAddReagent(jugSolnEnt.Value, sourceReagent.Reagent, removed, out _);
+
+            var reagentName = _prototypeManager.Index<ReagentPrototype>(reagentId).LocalizedName;
+            _popup.PopupEntity(Loc.GetString("plumbing-smart-dispenser-filled",
+                ("reagent", reagentName),
+                ("amount", removed)),
+                ent.Owner, args.User);
+        }
+
+        args.Handled = true;
+        UpdateUiState(ent);
+    }
+
+    /// <summary>
+    /// Attempts to match a label string to a reagent prototype ID.
+    /// Labels can contain rich text markup and abbreviations like ":[color=#ffaa00]BIC|BRT|15/5u".
+    /// The algorithm strips markup, skips leading punctuation, extracts the first alphabetic token,
+    /// then tries: 1) prefix match, 2) ordered subsequence match against all reagent names.
+    /// Results are cached for performance.
+    /// </summary>
+    private bool TryMatchLabelToReagent(string label, out string reagentId)
+    {
+        reagentId = string.Empty;
+
+        _labelCache ??= new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+
+        if (_labelCache.TryGetValue(label, out var cached))
+        {
+            reagentId = cached;
+            return true;
+        }
+
+        var stripped = StripBrackets(label);
+        var token = ExtractFirstAlphaToken(stripped);
+
+        Log.Debug($"SmartFridge label match: raw='{label}' stripped='{stripped}' token='{token}'");
+
+        if (string.IsNullOrEmpty(token) || token.Length < 2)
+            return false;
+
+        _reagentNames ??= BuildReagentNameList();
+
+        // Pass 1: Prefix match (covers exact matches too). Shortest name wins.
+        string? bestMatch = null;
+        var bestScore = int.MaxValue;
+
+        foreach (var (name, protoId) in _reagentNames)
+        {
+            if (name.Length >= token.Length
+                && name.StartsWith(token, StringComparison.OrdinalIgnoreCase)
+                && name.Length < bestScore)
+            {
+                bestMatch = protoId;
+                bestScore = name.Length;
+            }
+        }
+
+        // Pass 2: Ordered subsequence fallback. Strip spaces from token first.
+        if (bestMatch == null)
+        {
+            var compactToken = token.Replace(" ", "");
+            bestScore = int.MaxValue;
+
+            foreach (var (name, protoId) in _reagentNames)
+            {
+                var score = ScoreSubsequenceMatch(compactToken, name);
+                if (score != int.MinValue && score < bestScore)
+                {
+                    bestMatch = protoId;
+                    bestScore = score;
+                }
+            }
+        }
+
+        if (bestMatch == null)
+            return false;
+
+        reagentId = bestMatch;
+        _labelCache[label] = reagentId;
+        Log.Debug($"SmartFridge matched token='{token}' to reagent='{reagentId}'");
+        return true;
+    }
+
+    /// <summary>
+    /// Removes all bracket-enclosed blocks (e.g. [color=#ffaa00]) from a string.
+    /// </summary>
+    private static string StripBrackets(string text)
+    {
+        var sb = new System.Text.StringBuilder(text.Length);
+        var inBracket = false;
+
+        foreach (var c in text)
+        {
+            if (c == '[')
+                inBracket = true;
+            else if (c == ']')
+                inBracket = false;
+            else if (!inBracket)
+                sb.Append(c);
+        }
+
+        return sb.ToString();
+    }
+
+    /// <summary>
+    /// Scores an ordered subsequence match. Each char in token must appear in order in the name.
+    /// Primary score: consecutive prefix length (more = better).
+    /// Secondary: match span (compact = better). Tertiary: name length (shorter = better).
+    /// Returns a score (lower = better), or -1 if no match.
+    /// </summary>
+    private static int ScoreSubsequenceMatch(string token, string name)
+    {
+        var tokenIdx = 0;
+        var firstMatchPos = -1;
+        var lastMatchPos = -1;
+        var prefixLen = 0;
+        var countingPrefix = true;
+
+        for (var i = 0; i < name.Length && tokenIdx < token.Length; i++)
+        {
+            if (char.ToLowerInvariant(name[i]) == char.ToLowerInvariant(token[tokenIdx]))
+            {
+                if (firstMatchPos == -1)
+                    firstMatchPos = i;
+                lastMatchPos = i;
+
+                if (countingPrefix)
+                    prefixLen++;
+
+                tokenIdx++;
+            }
+            else if (countingPrefix)
+            {
+                countingPrefix = false;
+            }
+        }
+
+        if (tokenIdx < token.Length)
+            return int.MinValue;
+
+        return -(prefixLen * 100000) + (lastMatchPos - firstMatchPos) * 1000 + name.Length;
+    }
+
+    /// <summary>
+    /// Extracts the first run of letters (and internal spaces) from a string,
+    /// skipping leading non-letter characters. Stops at non-letter, non-space characters.
+    /// E.g. ":BIC|BRT" → "BIC", "dexalin plus" → "dexalin plus".
+    /// </summary>
+    private static string ExtractFirstAlphaToken(string text)
+    {
+        var start = -1;
+        var end = -1;
+
+        for (var i = 0; i < text.Length; i++)
+        {
+            if (char.IsLetter(text[i]))
+            {
+                if (start == -1)
+                    start = i;
+                end = i + 1;
+            }
+            else if (start != -1 && text[i] == ' ')
+            {
+                // Allow spaces between letters
+            }
+            else if (start != -1)
+            {
+                break;
+            }
+        }
+
+        if (start == -1)
+            return string.Empty;
+
+        return text[start..end].TrimEnd();
+    }
+
+    /// <summary>
+    /// Builds a sorted list of (localizedName, prototypeId) for all reagent prototypes.
+    /// Sorted by name length ascending so shorter (more specific) names are checked first.
+    /// </summary>
+    private List<(string LocalizedName, string PrototypeId)> BuildReagentNameList()
+    {
+        var list = new List<(string, string)>();
+
+        foreach (var proto in _prototypeManager.EnumeratePrototypes<ReagentPrototype>())
+        {
+            list.Add((proto.LocalizedName, proto.ID));
+        }
+
+        // Sort by name length so shorter matches win as tiebreaker
+        list.Sort((a, b) => a.Item1.Length.CompareTo(b.Item1.Length));
+        return list;
+    }
+
+    private void OnUIOpened(Entity<PlumbingSmartDispenserComponent> ent, ref AfterActivatableUIOpenEvent args)
+    {
+        UpdateUiState(ent);
+    }
+
+    private void UpdateUiState(Entity<PlumbingSmartDispenserComponent> ent)
+    {
+        var entries = new List<PlumbingSmartDispenserReagentEntry>();
+
+        if (_solutionSystem.TryGetSolution(ent.Owner, ent.Comp.SolutionName, out _, out var solution))
+        {
+            foreach (var reagent in solution.Contents)
+            {
+                if (reagent.Quantity <= FixedPoint2.Zero)
+                    continue;
+
+                if (!_prototypeManager.TryIndex<ReagentPrototype>(reagent.Reagent.Prototype, out var proto))
+                    continue;
+
+                entries.Add(new PlumbingSmartDispenserReagentEntry(
+                    proto.ID,
+                    proto.LocalizedName,
+                    reagent.Quantity,
+                    proto.SubstanceColor));
+            }
+
+            // Sort alphabetically by localized name for consistent display
+            entries.Sort((a, b) => string.Compare(a.LocalizedName, b.LocalizedName, StringComparison.OrdinalIgnoreCase));
+        }
+
+        var state = new PlumbingSmartDispenserBuiState(entries, ent.Comp.MaxPerReagent.Float());
+        _uiSystem.SetUiState(ent.Owner, PlumbingSmartDispenserUiKey.Key, state);
+    }
+}
diff --git a/Content.Server/_Starlight/Plumbing/EntitySystems/PlumbingSynthesizerSystem.cs b/Content.Server/_Starlight/Plumbing/EntitySystems/PlumbingSynthesizerSystem.cs
new file mode 100644
index 00000000000..f1ad096aaa2
--- /dev/null
+++ b/Content.Server/_Starlight/Plumbing/EntitySystems/PlumbingSynthesizerSystem.cs
@@ -0,0 +1,214 @@
+using Content.Server._Starlight.Plumbing.Components;
+using Content.Server.UserInterface;
+using Content.Shared._Starlight.Plumbing;
+using Content.Shared._Starlight.Plumbing.Components;
+using Content.Shared.Chemistry.EntitySystems;
+using Content.Shared.Chemistry.Reagent;
+using Content.Shared.FixedPoint;
+using Content.Shared.PowerCell;
+using Content.Shared.Power.EntitySystems;
+using Content.Shared.UserInterface;
+using JetBrains.Annotations;
+using Robust.Server.GameObjects;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
+using Robust.Shared.Timing;
+using SharedAppearanceSystem = Robust.Shared.GameObjects.SharedAppearanceSystem;
+
+namespace Content.Server._Starlight.Plumbing.EntitySystems;
+
+/// <summary>
+///     Handles plumbing synthesizer machine behavior: basically a small reagent dispenser,
+///     you can select a generatable reagent and it will produce it into its buffer container.
+///     Uses power from an internal battery and the reagents have the same power cost as reagent dispensers.
+///     Battery charging from APC is handled by <see cref="Content.Shared.Power.EntitySystems.ChargerSystem"/>.
+/// </summary>
+[UsedImplicitly]
+public sealed class PlumbingSynthesizerSystem : EntitySystem
+{
+    [Dependency] private readonly SharedSolutionContainerSystem _solutionSystem = default!;
+    [Dependency] private readonly UserInterfaceSystem _ui = default!;
+    [Dependency] private readonly PowerCellSystem _powerCell = default!;
+    [Dependency] private readonly SharedBatterySystem _battery = default!;
+    [Dependency] private readonly IGameTiming _timing = default!;
+    [Dependency] private readonly SharedAppearanceSystem _appearance = default!;
+    [Dependency] private readonly SharedAudioSystem _audio = default!;
+
+    private readonly Dictionary<EntityUid, TimeSpan> _nextUiUpdate = new();
+
+    /// <summary>
+    ///     How often to update the UI when open (in seconds).
+    /// </summary>
+    private const float UiUpdateIntervalSeconds = 0.5f;
+    private static readonly TimeSpan UiUpdateInterval = TimeSpan.FromSeconds(UiUpdateIntervalSeconds);
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<PlumbingSynthesizerComponent, PlumbingDeviceUpdateEvent>(OnSynthesizerUpdate);
+        SubscribeLocalEvent<PlumbingSynthesizerComponent, PlumbingSynthesizerToggleMessage>(OnToggle);
+        SubscribeLocalEvent<PlumbingSynthesizerComponent, PlumbingSynthesizerSelectReagentMessage>(OnSelectReagent);
+        SubscribeLocalEvent<PlumbingSynthesizerComponent, BoundUIOpenedEvent>(OnUIOpened);
+        SubscribeLocalEvent<PlumbingSynthesizerComponent, PlumbingPullAttemptEvent>(OnPullAttempt);
+        SubscribeLocalEvent<PlumbingSynthesizerComponent, ComponentRemove>(OnComponentRemove);
+    }
+
+    /// <summary>
+    ///     Update UI periodically when open.
+    /// </summary>
+    public override void Update(float frameTime)
+    {
+        base.Update(frameTime);
+
+        var curTime = _timing.CurTime;
+
+        var query = EntityQueryEnumerator<PlumbingSynthesizerComponent, ActivatableUIComponent>();
+        while (query.MoveNext(out var uid, out var synth, out var activatableUI))
+        {
+            var uiOpen = activatableUI.Key != null && _ui.IsUiOpen(uid, activatableUI.Key);
+            if (!uiOpen)
+                continue;
+
+            if (!_nextUiUpdate.TryGetValue(uid, out var nextUpdate) || curTime >= nextUpdate)
+            {
+                _nextUiUpdate[uid] = curTime + UiUpdateInterval;
+                UpdateUI((uid, synth));
+            }
+        }
+    }
+
+    private void OnComponentRemove(Entity<PlumbingSynthesizerComponent> ent, ref ComponentRemove args)
+    {
+        _nextUiUpdate.Remove(ent.Owner);
+    }
+
+    private void OnSynthesizerUpdate(Entity<PlumbingSynthesizerComponent> ent, ref PlumbingDeviceUpdateEvent args)
+    {
+        if (_solutionSystem.TryGetSolution(ent.Owner, ent.Comp.BufferSolutionName, out _, out var bufferCheck))
+            _appearance.SetData(ent.Owner, PlumbingVisuals.Running, bufferCheck.Volume > 0);
+
+        if (!ent.Comp.Enabled)
+            return;
+
+        if (ent.Comp.SelectedReagent == null)
+            return;
+
+        if (!_solutionSystem.TryGetSolution(ent.Owner, ent.Comp.BufferSolutionName, out var bufferEnt, out var buffer))
+            return;
+
+        var availableSpace = buffer.AvailableVolume;
+        if (availableSpace <= 0)
+            return;
+
+        if (!ent.Comp.GeneratableReagents.TryGetValue(ent.Comp.SelectedReagent.Value, out var powerDrain))
+            return;
+
+        var toGenerate = FixedPoint2.Min(availableSpace, buffer.MaxVolume);
+
+        var powerNeeded = powerDrain * (float)toGenerate;
+        if (!_powerCell.HasCharge(ent.Owner, powerNeeded))
+        {
+            if (!_powerCell.TryGetBatteryFromSlot(ent.Owner, out var batteryCheck))
+                return;
+
+            var availableCharge = batteryCheck.Value.Comp.LastCharge;
+            if (availableCharge <= 0)
+                return;
+
+            var affordableUnits = FixedPoint2.New((int)(availableCharge / powerDrain));
+            if (affordableUnits <= 0)
+                return;
+
+            toGenerate = FixedPoint2.Min(toGenerate, affordableUnits);
+            powerNeeded = powerDrain * (float)toGenerate;
+        }
+
+        if (!_powerCell.TryUseCharge(ent.Owner, powerNeeded))
+            return;
+
+        _solutionSystem.TryAddReagent(bufferEnt.Value, new ReagentId(ent.Comp.SelectedReagent.Value, null), toGenerate, out _);
+
+        _appearance.SetData(ent.Owner, PlumbingVisuals.Running, buffer.Volume > 0);
+        UpdateUI(ent);
+    }
+
+    /// <summary>
+    ///     Only allow pulling the selected reagent. Maybe not needed but trying to fix an issue
+    /// </summary>
+    private void OnPullAttempt(Entity<PlumbingSynthesizerComponent> ent, ref PlumbingPullAttemptEvent args)
+    {
+        if (ent.Comp.SelectedReagent == null || args.ReagentPrototype != ent.Comp.SelectedReagent)
+        {
+            args.Cancelled = true;
+        }
+    }
+
+    private void OnToggle(Entity<PlumbingSynthesizerComponent> ent, ref PlumbingSynthesizerToggleMessage args)
+    {
+        ent.Comp.Enabled = args.Enabled;
+        DirtyField(ent, ent.Comp, nameof(PlumbingSynthesizerComponent.Enabled));
+        ClickSound(ent.Owner);
+        UpdateUI(ent);
+    }
+
+    private void OnSelectReagent(Entity<PlumbingSynthesizerComponent> ent, ref PlumbingSynthesizerSelectReagentMessage args)
+    {
+        if (args.ReagentId == null)
+        {
+            ent.Comp.SelectedReagent = null;
+        }
+        else if (ent.Comp.GeneratableReagents.ContainsKey(args.ReagentId))
+        {
+            ent.Comp.SelectedReagent = args.ReagentId;
+        }
+
+        DirtyField(ent, ent.Comp, nameof(PlumbingSynthesizerComponent.SelectedReagent));
+        ClickSound(ent.Owner);
+        UpdateUI(ent);
+    }
+
+    private void OnUIOpened(Entity<PlumbingSynthesizerComponent> ent, ref BoundUIOpenedEvent args)
+    {
+        UpdateUI(ent);
+    }
+
+    private void UpdateUI(Entity<PlumbingSynthesizerComponent> ent)
+    {
+        if (!_solutionSystem.TryGetSolution(ent.Owner, ent.Comp.BufferSolutionName, out _, out var buffer))
+            return;
+
+        var batteryCharge = 0f;
+        if (_powerCell.TryGetBatteryFromSlot(ent.Owner, out var battery))
+        {
+            batteryCharge = _battery.GetChargeLevel(battery.Value.AsNullable());
+        }
+
+        var generatableReagents = new Dictionary<string, float>();
+        foreach (var (reagent, drain) in ent.Comp.GeneratableReagents)
+        {
+            generatableReagents[reagent.Id] = drain;
+        }
+
+        var bufferContents = new Dictionary<string, FixedPoint2>();
+        foreach (var reagent in buffer.Contents)
+        {
+            bufferContents[reagent.Reagent.Prototype] = reagent.Quantity;
+        }
+
+        var state = new PlumbingSynthesizerBoundUserInterfaceState(
+            generatableReagents,
+            ent.Comp.SelectedReagent?.Id,
+            bufferContents,
+            ent.Comp.Enabled,
+            batteryCharge);
+
+        _ui.SetUiState(ent.Owner, PlumbingSynthesizerUiKey.Key, state);
+    }
+
+    private void ClickSound(EntityUid uid)
+    {
+        if (TryComp<PlumbingDeviceComponent>(uid, out var device))
+            _audio.PlayPvs(device.ClickSound, uid, AudioParams.Default.WithVolume(-2f));
+    }
+}
diff --git a/Content.Server/_Starlight/Plumbing/NodeGroups/PlumbingNet.cs b/Content.Server/_Starlight/Plumbing/NodeGroups/PlumbingNet.cs
new file mode 100644
index 00000000000..0c312a0e97a
--- /dev/null
+++ b/Content.Server/_Starlight/Plumbing/NodeGroups/PlumbingNet.cs
@@ -0,0 +1,18 @@
+using Content.Server.NodeContainer.NodeGroups;
+using Content.Shared.NodeContainer;
+using Content.Shared.NodeContainer.NodeGroups;
+
+namespace Content.Server._Starlight.Plumbing.NodeGroups;
+
+public interface IPlumbingNet : INodeGroup
+{
+}
+
+[NodeGroup(NodeGroupID.Plumbing)]
+public sealed class PlumbingNet : BaseNodeGroup, IPlumbingNet
+{
+    public override string? GetDebugData()
+    {
+        return $"Nodes: {NodeCount}";
+    }
+}
diff --git a/Content.Server/_Starlight/Plumbing/Nodes/PlumbingNode.cs b/Content.Server/_Starlight/Plumbing/Nodes/PlumbingNode.cs
new file mode 100644
index 00000000000..0bf5fa63712
--- /dev/null
+++ b/Content.Server/_Starlight/Plumbing/Nodes/PlumbingNode.cs
@@ -0,0 +1,20 @@
+using Content.Server._Starlight.Plumbing.NodeGroups;
+using Content.Server.NodeContainer.Nodes;
+
+namespace Content.Server._Starlight.Plumbing.Nodes;
+
+/// <summary>
+///     A pipe node for plumbing systems using reagents instead of gases.
+///     Extends PipeNode to reuse all pipe connection logic (direction, color, layer matching).
+///     The only difference is it uses PlumbingNet instead of PipeNet.
+/// </summary>
+[DataDefinition]
+[Virtual]
+public partial class PlumbingNode : PipeNode
+{
+    /// <summary>
+    ///     The <see cref="IPlumbingNet"/> this plumbing duct is part of.
+    /// </summary>
+    [ViewVariables]
+    public IPlumbingNet? PlumbingNet => (IPlumbingNet?) NodeGroup;
+}
diff --git a/Content.Server/_Starlight/Plumbing/PlumbingPullAttemptEvent.cs b/Content.Server/_Starlight/Plumbing/PlumbingPullAttemptEvent.cs
new file mode 100644
index 00000000000..370612ef6ea
--- /dev/null
+++ b/Content.Server/_Starlight/Plumbing/PlumbingPullAttemptEvent.cs
@@ -0,0 +1,41 @@
+using Content.Shared.Chemistry.Reagent;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Prototypes;
+
+namespace Content.Server._Starlight.Plumbing;
+
+/// <summary>
+///     Raised on the SOURCE entity when a machine attempts to pull a specific reagent.
+///     Allows for cancelling the pull of specific reagents when subscribed to.
+/// </summary>
+[ByRefEvent]
+public struct PlumbingPullAttemptEvent
+{
+    /// <summary>
+    ///     The entity attempting to pull reagents.
+    /// </summary>
+    public EntityUid Puller;
+
+    /// <summary>
+    ///     The name of the node being pulled from.
+    /// </summary>
+    public string NodeName;
+
+    /// <summary>
+    ///     The reagent prototype ID being checked.
+    /// </summary>
+    public ProtoId<ReagentPrototype> ReagentPrototype;
+
+    /// <summary>
+    ///     Set to true to deny pulling this reagent.
+    /// </summary>
+    public bool Cancelled;
+
+    public PlumbingPullAttemptEvent(EntityUid puller, string nodeName, ProtoId<ReagentPrototype> reagentPrototype)
+    {
+        Puller = puller;
+        NodeName = nodeName;
+        ReagentPrototype = reagentPrototype;
+        Cancelled = false;
+    }
+}
diff --git a/Content.Server/_Starlight/Plumbing/PlumbingPullIntoAttemptEvent.cs b/Content.Server/_Starlight/Plumbing/PlumbingPullIntoAttemptEvent.cs
new file mode 100644
index 00000000000..35ab9350cad
--- /dev/null
+++ b/Content.Server/_Starlight/Plumbing/PlumbingPullIntoAttemptEvent.cs
@@ -0,0 +1,48 @@
+using Content.Shared.FixedPoint;
+using Robust.Shared.GameObjects;
+
+namespace Content.Server._Starlight.Plumbing;
+
+/// <summary>
+///     Raised on the DESTINATION (puller) entity when a reagent is about to be pulled into it.
+///     Handlers can reduce <see cref="MaxAllowed"/> to cap the pull amount,
+///     or set <see cref="Cancelled"/> to deny the pull entirely.
+/// </summary>
+[ByRefEvent]
+public struct PlumbingPullIntoAttemptEvent
+{
+    /// <summary>
+    ///     The source entity being pulled from.
+    /// </summary>
+    public EntityUid Source;
+
+    /// <summary>
+    ///     The reagent prototype ID being pulled.
+    /// </summary>
+    public string ReagentPrototype;
+
+    /// <summary>
+    ///     The amount the system wants to pull. Read-only reference value.
+    /// </summary>
+    public FixedPoint2 Amount;
+
+    /// <summary>
+    ///     Maximum amount the destination will accept. Handlers can lower this
+    ///     (but not raise it above <see cref="Amount"/>). Defaults to <see cref="Amount"/>.
+    /// </summary>
+    public FixedPoint2 MaxAllowed;
+
+    /// <summary>
+    ///     Set to true to fully deny pulling this reagent.
+    /// </summary>
+    public bool Cancelled;
+
+    public PlumbingPullIntoAttemptEvent(EntityUid source, string reagentPrototype, FixedPoint2 amount)
+    {
+        Source = source;
+        ReagentPrototype = reagentPrototype;
+        Amount = amount;
+        MaxAllowed = amount;
+        Cancelled = false;
+    }
+}
diff --git a/Content.Shared/Chemistry/SharedChemMaster.cs b/Content.Shared/Chemistry/SharedChemMaster.cs
index cabee465eaa..6623abc7df6 100644
--- a/Content.Shared/Chemistry/SharedChemMaster.cs
+++ b/Content.Shared/Chemistry/SharedChemMaster.cs
@@ -14,6 +14,7 @@ public sealed class SharedChemMaster
         public const string InputSlotName = "beakerSlot";
         public const string OutputSlotName = "outputSlot";
         public const string PillSolutionName = "food";
+        public const string PatchSolutionName = "patch"; // Starlight Plumbing
         public const string BottleSolutionName = "drink";
         public const uint LabelMaxLength = 50;
     }
diff --git a/Content.Shared/NodeContainer/NodeGroups/NodeGroupID.cs b/Content.Shared/NodeContainer/NodeGroups/NodeGroupID.cs
index f76a4f9022a..5a6a9db8ef3 100644
--- a/Content.Shared/NodeContainer/NodeGroups/NodeGroupID.cs
+++ b/Content.Shared/NodeContainer/NodeGroups/NodeGroupID.cs
@@ -17,4 +17,9 @@ public enum NodeGroupID : byte
     /// <seealso cref="Content.Server.Power.Generation.Teg.TegNodeGroup"/>
     Teg,
     ExCable,
+
+    /// <summary>
+    /// Group used for plumbing (reagent fluid ducts).
+    /// </summary>
+    Plumbing, // Starlight Plumbing System
 }
diff --git a/Content.Shared/RCD/Components/RCDDeconstructibleComponent.cs b/Content.Shared/RCD/Components/RCDDeconstructibleComponent.cs
index 0ddc6897f05..1057b31c48e 100644
--- a/Content.Shared/RCD/Components/RCDDeconstructibleComponent.cs
+++ b/Content.Shared/RCD/Components/RCDDeconstructibleComponent.cs
@@ -31,4 +31,12 @@ public sealed partial class RCDDeconstructableComponent : Component
     /// </summary>
     [DataField, ViewVariables(VVAccess.ReadWrite)]
     public bool Deconstructable = true;
+
+    // Starlight Plumbing Start
+    /// <summary>
+    /// Toggles whether this entity is deconstructable by the RPLD (plumbing) or not
+    /// </summary>
+    [DataField("rpld"), ViewVariables(VVAccess.ReadWrite)]
+    public bool RpldDeconstructable = false;
+    // Starlight Plumbing End
 }
diff --git a/Content.Shared/_Starlight/Medical/Items/Components/PatchComponent.cs b/Content.Shared/_Starlight/Medical/Items/Components/PatchComponent.cs
new file mode 100644
index 00000000000..478567cdd8a
--- /dev/null
+++ b/Content.Shared/_Starlight/Medical/Items/Components/PatchComponent.cs
@@ -0,0 +1,29 @@
+using Robust.Shared.Audio;
+
+namespace Content.Shared.Starlight.Medical.Items.Components;
+
+[RegisterComponent]
+public sealed partial class PatchComponent : Component
+{
+    [DataField]
+    public string SolutionContainer = "patch";
+    
+        /// <summary>
+        /// How long it takes to apply patch.
+        /// </summary>
+        [ViewVariables(VVAccess.ReadWrite)]
+        [DataField("delay")]
+        public float Delay = 3f;
+        
+        /// <summary>
+        ///     Sound played on apply begin
+        /// </summary>
+        [DataField("healingBeginSound")]
+        public SoundSpecifier? ApplyBeginSound = null;
+
+        /// <summary>
+        ///     Sound played on apply end
+        /// </summary>
+        [DataField("healingEndSound")]
+        public SoundSpecifier? ApplyEndSound = null;
+}
\ No newline at end of file
diff --git a/Content.Shared/_Starlight/Plumbing/Components/PlumbingConnectorAppearanceComponent.cs b/Content.Shared/_Starlight/Plumbing/Components/PlumbingConnectorAppearanceComponent.cs
new file mode 100644
index 00000000000..2d1b0f65eee
--- /dev/null
+++ b/Content.Shared/_Starlight/Plumbing/Components/PlumbingConnectorAppearanceComponent.cs
@@ -0,0 +1,36 @@
+using Robust.Shared.Utility;
+
+namespace Content.Shared._Starlight.Plumbing.Components;
+
+/// <summary>
+/// Adds dynamic connector sprites to plumbing machines.
+/// Shows jagged connectors where nodes exist and switches layer to smooth ends version when connected.
+/// </summary>
+[RegisterComponent]
+public sealed partial class PlumbingConnectorAppearanceComponent : Component
+{
+    /// <summary>
+    /// Sprite for disconnected (jagged) connectors.
+    /// </summary>
+    [DataField]
+    public SpriteSpecifier.Rsi Disconnected = new(new("_Starlight/Structures/Piping/Plumbing/plumbers.rsi"), "ductConnector");
+
+    /// <summary>
+    /// Sprite for connected (smooth) connectors - overlays disconnected state.
+    /// </summary>
+    [DataField]
+    public SpriteSpecifier.Rsi Connected = new(new("_Starlight/Structures/Piping/Plumbing/plumbers.rsi"), "ductConnector_connected");
+
+    /// <summary>
+    /// Offset from center for connector sprites. Used so jagged ends stick out from under a machine to be visible under big sprites.
+    /// </summary>
+    [DataField]
+    public float Offset;
+
+    /// <summary>
+    /// Node names that should be colored as mixing inlets (green).
+    /// Configured per-entity in YAML, matching how inlets/outlets are classified by component data.
+    /// </summary>
+    [DataField]
+    public HashSet<string> MixingInletNames = new();
+}
diff --git a/Content.Shared/_Starlight/Plumbing/Components/PlumbingFilterComponent.cs b/Content.Shared/_Starlight/Plumbing/Components/PlumbingFilterComponent.cs
new file mode 100644
index 00000000000..baa678fc8d2
--- /dev/null
+++ b/Content.Shared/_Starlight/Plumbing/Components/PlumbingFilterComponent.cs
@@ -0,0 +1,48 @@
+using Content.Shared.Chemistry.Reagent;
+using Content.Shared.FixedPoint;
+using Robust.Shared.GameStates;
+using Robust.Shared.Prototypes;
+
+namespace Content.Shared._Starlight.Plumbing.Components;
+
+/// <summary>
+///     A plumbing filter that separates reagents into two outputs.
+///     Pulls reagents from the inlet into a buffer, then restricts which reagents
+///     can be pulled from each outlet via <see cref="PlumbingPullAttemptEvent"/>.
+///     Filter outlet only provides reagents in the filter list.
+///     Passthrough outlet only provides reagents NOT in the filter list.
+/// </summary>
+[RegisterComponent, NetworkedComponent, AutoGenerateComponentState(fieldDeltas: true)]
+public sealed partial class PlumbingFilterComponent : Component
+{
+    /// <summary>
+    ///     Name of the filter outlet node - only filtered reagents can be pulled here.
+    /// </summary>
+    [DataField]
+    public string FilterNodeName = "outletFilter";
+
+    /// <summary>
+    ///     Name of the passthrough outlet node - only non-filtered reagents can be pulled here.
+    /// </summary>
+    [DataField]
+    public string PassthroughNodeName = "outletPassthrough";
+
+    /// <summary>
+    ///     Name of the solution buffer that holds the reagents.
+    /// </summary>
+    [DataField]
+    public string BufferSolutionName = "buffer";
+
+    /// <summary>
+    ///     Whether the filter is currently enabled.
+    /// </summary>
+    [DataField, AutoNetworkedField]
+    public bool Enabled = true;
+
+    /// <summary>
+    ///     The reagent IDs to filter out to the filter port.
+    ///     Multiple reagents can be filtered simultaneously.
+    /// </summary>
+    [DataField, AutoNetworkedField]
+    public HashSet<ProtoId<ReagentPrototype>> FilteredReagents = new();
+}
diff --git a/Content.Shared/_Starlight/Plumbing/Components/PlumbingInletComponent.cs b/Content.Shared/_Starlight/Plumbing/Components/PlumbingInletComponent.cs
new file mode 100644
index 00000000000..8ea89f63589
--- /dev/null
+++ b/Content.Shared/_Starlight/Plumbing/Components/PlumbingInletComponent.cs
@@ -0,0 +1,40 @@
+using Content.Shared.FixedPoint;
+
+namespace Content.Shared._Starlight.Plumbing.Components;
+
+/// <summary>
+///     A plumbing inlet that pulls reagents from the network.
+///     Actively pulls reagents from its inlet nodes each update tick into the specified solution.
+///     Each inlet node connects to its own plumbing network, preventing network bridging
+///     through multi-connector machines.
+///     Other machines can pull from this entity via <see cref="PlumbingOutletComponent"/>.
+/// </summary>
+[RegisterComponent]
+public sealed partial class PlumbingInletComponent : Component
+{
+    /// <summary>
+    ///     The name of the solution on this entity to pull reagents into.
+    /// </summary>
+    [DataField]
+    public string SolutionName = "tank";
+
+    /// <summary>
+    ///     The names of the inlet nodes to pull from.
+    ///     Each node should be a single-direction PlumbingNode so that each direction
+    ///     has its own isolated network.
+    /// </summary>
+    [DataField]
+    public List<string> InletNames = new() { "inlet" };
+
+    /// <summary>
+    ///     Amount to transfer per update, shared across all inlets.
+    /// </summary>
+    [DataField]
+    public FixedPoint2 TransferAmount = FixedPoint2.New(20);
+
+    /// <summary>
+    ///     Round-robin indices for fair outlet selection.
+    ///     Tracks which outlet to start from when pulling from multiple sources on each network.
+    /// </summary>
+    public Dictionary<string, int> RoundRobinIndices = new();
+}
diff --git a/Content.Shared/_Starlight/Plumbing/Components/PlumbingInputComponent.cs b/Content.Shared/_Starlight/Plumbing/Components/PlumbingInputComponent.cs
new file mode 100644
index 00000000000..6a78ab9ddcd
--- /dev/null
+++ b/Content.Shared/_Starlight/Plumbing/Components/PlumbingInputComponent.cs
@@ -0,0 +1,16 @@
+namespace Content.Shared._Starlight.Plumbing.Components;
+
+/// <summary>
+///     A plumbing input that players can pour reagents into using containers.
+///     Paired with <see cref="PlumbingOutletComponent"/> to allow other machines
+///     to pull reagents from its solution via the plumbing network.
+/// </summary>
+[RegisterComponent]
+public sealed partial class PlumbingInputComponent : Component
+{
+    /// <summary>
+    ///     The name of the solution on this entity that receives input.
+    /// </summary>
+    [DataField]
+    public string SolutionName = "input";
+}
diff --git a/Content.Shared/_Starlight/Plumbing/Components/PlumbingOutletComponent.cs b/Content.Shared/_Starlight/Plumbing/Components/PlumbingOutletComponent.cs
new file mode 100644
index 00000000000..133d7994c4d
--- /dev/null
+++ b/Content.Shared/_Starlight/Plumbing/Components/PlumbingOutletComponent.cs
@@ -0,0 +1,40 @@
+using System.Collections.Generic;
+using Robust.Shared.GameStates;
+
+namespace Content.Shared._Starlight.Plumbing.Components;
+
+/// <summary>
+///     Marks an entity as a reagent source on the plumbing network.
+///     <see cref="PlumbingPullSystem"/> discovers entities with this component
+///     when other machines request reagents from the network.
+/// </summary>
+[RegisterComponent, NetworkedComponent, AutoGenerateComponentState]
+public sealed partial class PlumbingOutletComponent : Component
+{
+    /// <summary>
+    ///     The name of the solution to provide to the network.
+    /// </summary>
+    [DataField]
+    public string SolutionName = "tank";
+
+    /// <summary>
+    ///     The outlet node names that serve this solution.
+    ///     Defaults to a single "outlet" node. Devices with multiple outlets
+    ///     (e.g. the filter) can list several names.
+    /// </summary>
+    [DataField]
+    public List<string> OutletNames = new() { "outlet" };
+
+    /// <summary>
+    ///     If true, this outlet can be pulled from. If false, it's blocked.
+    /// </summary>
+    [DataField, AutoNetworkedField]
+    public bool Enabled = true;
+
+    /// <summary>
+    ///     If set, look for the solution on the entity in this container slot instead of on this entity.
+    ///     Useful for machines like dispensers where the solution is in a beaker.
+    /// </summary>
+    [DataField]
+    public string? ContainerSlotId;
+}
diff --git a/Content.Shared/_Starlight/Plumbing/Components/PlumbingOutputComponent.cs b/Content.Shared/_Starlight/Plumbing/Components/PlumbingOutputComponent.cs
new file mode 100644
index 00000000000..2b2b639342f
--- /dev/null
+++ b/Content.Shared/_Starlight/Plumbing/Components/PlumbingOutputComponent.cs
@@ -0,0 +1,15 @@
+namespace Content.Shared._Starlight.Plumbing.Components;
+
+/// <summary>
+///     A plumbing output that players can draw reagents from using containers.
+///     Pulling from the network is handled by <see cref="PlumbingInletComponent"/>.
+/// </summary>
+[RegisterComponent]
+public sealed partial class PlumbingOutputComponent : Component
+{
+    /// <summary>
+    ///     The name of the solution on this entity that players can draw from.
+    /// </summary>
+    [DataField]
+    public string SolutionName = "output";
+}
diff --git a/Content.Shared/_Starlight/Plumbing/Components/PlumbingPillPressComponent.cs b/Content.Shared/_Starlight/Plumbing/Components/PlumbingPillPressComponent.cs
new file mode 100644
index 00000000000..640a3386690
--- /dev/null
+++ b/Content.Shared/_Starlight/Plumbing/Components/PlumbingPillPressComponent.cs
@@ -0,0 +1,94 @@
+using Content.Shared.FixedPoint;
+using Robust.Shared.GameStates;
+
+namespace Content.Shared._Starlight.Plumbing.Components;
+
+/// <summary>
+///     A plumbing pill press that automatically creates pills or patches
+///     from reagents pulled through its inlet network.
+///     When the buffer accumulates enough reagents to meet the dosage,
+///     it spawns a pill or patch entity on the ground containing those reagents.
+///     Supports optional mixing mode with two configurable ratio inlets (E/W)
+///     in addition to the normal north inlet.
+/// </summary>
+[RegisterComponent, NetworkedComponent, AutoGenerateComponentState(fieldDeltas: true)]
+public sealed partial class PlumbingPillPressComponent : Component
+{
+    /// <summary>
+    ///     Name of the buffer solution that holds incoming reagents.
+    /// </summary>
+    [DataField]
+    public string BufferSolutionName = "buffer";
+
+    /// <summary>
+    ///     The dosage per pill/patch in units. Clamped 1–20.
+    /// </summary>
+    [DataField, AutoNetworkedField]
+    public uint Dosage = 10;
+
+    /// <summary>
+    ///     Whether we're producing pills or patches.
+    /// </summary>
+    [DataField, AutoNetworkedField]
+    public PillPressOutputMode OutputMode = PillPressOutputMode.Pill;
+
+    /// <summary>
+    ///     The pill visual type (0–19). Only relevant for pills.
+    /// </summary>
+    [DataField, AutoNetworkedField]
+    public uint PillType;
+
+    /// <summary>
+    ///     Whether the press is enabled and will pull/produce.
+    /// </summary>
+    [DataField, AutoNetworkedField]
+    public bool Enabled = true;
+
+    // =========================================================================
+    // Mixing mode fields
+    // =========================================================================
+
+    /// <summary>
+    ///     Whether ratio-controlled mixing is active.
+    ///     When enabled, E/W inlets pull proportionally into staging solutions
+    ///     and combine into the buffer when targets are met.
+    /// </summary>
+    [DataField, AutoNetworkedField]
+    public bool MixingEnabled;
+
+    /// <summary>
+    ///     Ratio percentage for the east inlet (0–100).
+    /// </summary>
+    [DataField, AutoNetworkedField]
+    public float InletRatioEast;
+
+    /// <summary>
+    ///     Ratio percentage for the west inlet (0–100).
+    /// </summary>
+    [DataField, AutoNetworkedField]
+    public float InletRatioWest;
+
+    /// <summary>
+    ///     Name of the east staging solution.
+    /// </summary>
+    [DataField]
+    public string StagingEastSolutionName = "stagingEast";
+
+    /// <summary>
+    ///     Name of the west staging solution.
+    /// </summary>
+    [DataField]
+    public string StagingWestSolutionName = "stagingWest";
+
+    /// <summary>
+    ///     Node name for the east inlet.
+    /// </summary>
+    [DataField]
+    public string InletEastNodeName = "mixingInletEast";
+
+    /// <summary>
+    ///     Node name for the west inlet.
+    /// </summary>
+    [DataField]
+    public string InletWestNodeName = "mixingInletWest";
+}
diff --git a/Content.Shared/_Starlight/Plumbing/Components/PlumbingReactorComponent.cs b/Content.Shared/_Starlight/Plumbing/Components/PlumbingReactorComponent.cs
new file mode 100644
index 00000000000..21b509251df
--- /dev/null
+++ b/Content.Shared/_Starlight/Plumbing/Components/PlumbingReactorComponent.cs
@@ -0,0 +1,67 @@
+using Content.Shared.Atmos;
+using Content.Shared.Chemistry.Reagent;
+using Content.Shared.FixedPoint;
+using Robust.Shared.GameStates;
+using Robust.Shared.Prototypes;
+
+namespace Content.Shared._Starlight.Plumbing.Components;
+
+/// <summary>
+///     A plumbing reactor that accumulates reagents and triggers chemical reactions.
+///     Pulls specific reagents from the inlet until target quantities are met,
+///     then triggers reactions in the buffer at a configurable temperature.
+///     Products are moved to an output solution for other machines to pull.
+/// </summary>
+[RegisterComponent, NetworkedComponent, AutoGenerateComponentState(fieldDeltas: true)]
+public sealed partial class PlumbingReactorComponent : Component
+{
+    /// <summary>
+    ///     Name of the inlet node for pulling reagents from the network.
+    /// </summary>
+    [DataField]
+    public string InletName = "inlet";
+
+    /// <summary>
+    ///     Name of the buffer solution that holds reagents waiting to react.
+    /// </summary>
+    [DataField]
+    public string BufferSolutionName = "buffer";
+
+    /// <summary>
+    ///     Name of the output solution that holds reacted products.
+    /// </summary>
+    [DataField]
+    public string OutputSolutionName = "output";
+
+    /// <summary>
+    ///     Amount to pull from tanks per update.
+    /// </summary>
+    [DataField]
+    public FixedPoint2 TransferAmount = FixedPoint2.New(20);
+
+    /// <summary>
+    ///     Whether the reactor is currently enabled.
+    /// </summary>
+    [DataField, AutoNetworkedField]
+    public bool Enabled = true;
+
+    /// <summary>
+    ///     The reagent targets to accumulate. Key is reagent prototype ID, value is target quantity.
+    ///     When all targets are met, the buffer triggers reactions and moves products to output.
+    /// </summary>
+    [DataField, AutoNetworkedField]
+    public Dictionary<ProtoId<ReagentPrototype>, FixedPoint2> ReagentTargets = new();
+
+    /// <summary>
+    ///     Target temperature for the buffer solution in Kelvin.
+    ///     The reactor will heat or cool the buffer to reach this temperature.
+    /// </summary>
+    [DataField, AutoNetworkedField]
+    public float TargetTemperature = Atmospherics.T20C;
+
+    /// <summary>
+    ///     Maximum heat transfer rate when powered, in watts.
+    /// </summary>
+    [DataField]
+    public float HeatTransferPower = 500f;
+}
diff --git a/Content.Shared/_Starlight/Plumbing/Components/PlumbingSmartDispenserComponent.cs b/Content.Shared/_Starlight/Plumbing/Components/PlumbingSmartDispenserComponent.cs
new file mode 100644
index 00000000000..a138e9dfbc5
--- /dev/null
+++ b/Content.Shared/_Starlight/Plumbing/Components/PlumbingSmartDispenserComponent.cs
@@ -0,0 +1,24 @@
+using Content.Shared.FixedPoint;
+using Robust.Shared.GameStates;
+
+namespace Content.Shared._Starlight.Plumbing.Components;
+
+/// <summary>
+/// A plumbing-connected smart dispenser that stores reagents pulled from the network
+/// and fills labeled jugs on interaction.
+/// </summary>
+[RegisterComponent, NetworkedComponent]
+public sealed partial class PlumbingSmartDispenserComponent : Component
+{
+    /// <summary>
+    /// The solution container name for the dispenser's reagent storage.
+    /// </summary>
+    [DataField]
+    public string SolutionName = "fridge";
+
+    /// <summary>
+    /// Maximum amount of any single reagent the fridge can store.
+    /// </summary>
+    [DataField]
+    public FixedPoint2 MaxPerReagent = FixedPoint2.New(200);
+}
diff --git a/Content.Shared/_Starlight/Plumbing/Components/PlumbingSynthesizerComponent.cs b/Content.Shared/_Starlight/Plumbing/Components/PlumbingSynthesizerComponent.cs
new file mode 100644
index 00000000000..60d9b3a0b66
--- /dev/null
+++ b/Content.Shared/_Starlight/Plumbing/Components/PlumbingSynthesizerComponent.cs
@@ -0,0 +1,46 @@
+using Content.Shared.Chemistry.Reagent;
+using Robust.Shared.GameStates;
+using Robust.Shared.Prototypes;
+
+namespace Content.Shared._Starlight.Plumbing.Components;
+
+/// <summary>
+///     A plumbing synthesizer that generates reagents from electrical power.
+///     Drains power from its battery to produce a selected reagent into
+///     its buffer. Other machines can pull the generated reagents via
+///     the <see cref="PlumbingOutletComponent"/> on this entity.
+/// </summary>
+[RegisterComponent, NetworkedComponent, AutoGenerateComponentState(fieldDeltas: true)]
+public sealed partial class PlumbingSynthesizerComponent : Component
+{
+    /// <summary>
+    ///     Name of the outlet node for the plumbing network.
+    /// </summary>
+    [DataField]
+    public string OutletName = "outlet";
+
+    /// <summary>
+    ///     Name of the buffer solution that holds generated reagents.
+    /// </summary>
+    [DataField]
+    public string BufferSolutionName = "buffer";
+
+    /// <summary>
+    ///     Available reagents that can be generated.
+    ///     Key is reagent prototype ID, value is power drain per unit.
+    /// </summary>
+    [DataField, AutoNetworkedField]
+    public Dictionary<ProtoId<ReagentPrototype>, float> GeneratableReagents = new();
+
+    /// <summary>
+    ///     Currently selected reagent to generate. Null if none selected.
+    /// </summary>
+    [DataField, AutoNetworkedField]
+    public ProtoId<ReagentPrototype>? SelectedReagent;
+
+    /// <summary>
+    ///     Whether the synthesizer is currently enabled.
+    /// </summary>
+    [DataField, AutoNetworkedField]
+    public bool Enabled = true;
+}
diff --git a/Content.Shared/_Starlight/Plumbing/Components/PlungeableComponent.cs b/Content.Shared/_Starlight/Plumbing/Components/PlungeableComponent.cs
new file mode 100644
index 00000000000..f1d2d9cf706
--- /dev/null
+++ b/Content.Shared/_Starlight/Plumbing/Components/PlungeableComponent.cs
@@ -0,0 +1,17 @@
+using Robust.Shared.Audio;
+
+namespace Content.Shared._Starlight.Plumbing.Components;
+
+/// <summary>
+///     Marker component for plumbing machines that can be plunged.
+///     When a plunger is used on this entity, all solution containers are emptied onto the floor.
+/// </summary>
+[RegisterComponent]
+public sealed partial class PlungeableComponent : Component
+{
+    /// <summary>
+    ///     Sound played when the machine is successfully drained.
+    /// </summary>
+    [DataField]
+    public SoundSpecifier DrainSound = new SoundPathSpecifier("/Audio/Effects/Fluids/slosh.ogg");
+}
diff --git a/Content.Shared/_Starlight/Plumbing/PlumbingVisuals.cs b/Content.Shared/_Starlight/Plumbing/PlumbingVisuals.cs
new file mode 100644
index 00000000000..041b3b3e2b8
--- /dev/null
+++ b/Content.Shared/_Starlight/Plumbing/PlumbingVisuals.cs
@@ -0,0 +1,55 @@
+using Robust.Shared.Serialization;
+
+namespace Content.Shared._Starlight.Plumbing;
+
+[Serializable, NetSerializable]
+public enum PlumbingVisuals : byte
+{
+    /// <summary>
+    ///     Whether the plumbing machine is actively running.
+    /// </summary>
+    Running,
+
+    /// <summary>
+    ///     Directions that have PlumbingNodes defined.
+    ///     Used to show jagged connectors in those directions.
+    /// </summary>
+    NodeDirections,
+
+    /// <summary>
+    ///     Directions that are connected.
+    ///     Used to show smooth connector layer instead when connected.
+    /// </summary>
+    ConnectedDirections,
+
+    /// <summary>
+    ///     Directions that have inlet nodes.
+    ///     Used to color inlet connectors red.
+    /// </summary>
+    InletDirections,
+
+    /// <summary>
+    ///     Directions that have outlet nodes.
+    ///     Used to color outlet connectors blue.
+    /// </summary>
+    OutletDirections,
+
+    /// <summary>
+    ///     Whether the entity is covered by a floor tile.
+    ///     Used to hide connector layers under floors without using SubFloorHide.
+    /// </summary>
+    CoveredByFloor,
+
+    /// <summary>
+    ///     Directions that have mixing inlet nodes.
+    ///     Used to color mixing inlet connectors green.
+    /// </summary>
+    MixingInletDirections
+}
+
+[Serializable, NetSerializable]
+public enum PlumbingVisualLayers : byte
+{
+    Base,
+    Overlay
+}
diff --git a/Content.Shared/_Starlight/Plumbing/SharedPlumbingFilter.cs b/Content.Shared/_Starlight/Plumbing/SharedPlumbingFilter.cs
new file mode 100644
index 00000000000..7e161b833d3
--- /dev/null
+++ b/Content.Shared/_Starlight/Plumbing/SharedPlumbingFilter.cs
@@ -0,0 +1,84 @@
+using Content.Shared.FixedPoint;
+using Robust.Shared.Serialization;
+
+namespace Content.Shared._Starlight.Plumbing;
+
+/// <summary>
+///     UI key for the plumbing filter interface.
+/// </summary>
+[Serializable, NetSerializable]
+public enum PlumbingFilterUiKey : byte
+{
+    Key,
+}
+
+/// <summary>
+///     State sent to the client to update the filter UI.
+/// </summary>
+[Serializable, NetSerializable]
+public sealed class PlumbingFilterBoundUserInterfaceState : BoundUserInterfaceState
+{
+    /// <summary>
+    ///     The reagent IDs currently being filtered.
+    /// </summary>
+    public HashSet<string> FilteredReagents { get; }
+
+    /// <summary>
+    ///     Whether the filter is enabled.
+    /// </summary>
+    public bool Enabled { get; }
+
+    public PlumbingFilterBoundUserInterfaceState(HashSet<string> filteredReagents, bool enabled)
+    {
+        FilteredReagents = filteredReagents;
+        Enabled = enabled;
+    }
+}
+
+/// <summary>
+///     Message to toggle the filter on/off.
+/// </summary>
+[Serializable, NetSerializable]
+public sealed class PlumbingFilterToggleMessage : BoundUserInterfaceMessage
+{
+    public bool Enabled { get; }
+
+    public PlumbingFilterToggleMessage(bool enabled)
+    {
+        Enabled = enabled;
+    }
+}
+
+/// <summary>
+///     Message to add a reagent to the filter list.
+/// </summary>
+[Serializable, NetSerializable]
+public sealed class PlumbingFilterAddReagentMessage : BoundUserInterfaceMessage
+{
+    public string ReagentId { get; }
+
+    public PlumbingFilterAddReagentMessage(string reagentId)
+    {
+        ReagentId = reagentId;
+    }
+}
+
+/// <summary>
+///     Message to remove a reagent from the filter list.
+/// </summary>
+[Serializable, NetSerializable]
+public sealed class PlumbingFilterRemoveReagentMessage : BoundUserInterfaceMessage
+{
+    public string ReagentId { get; }
+
+    public PlumbingFilterRemoveReagentMessage(string reagentId)
+    {
+        ReagentId = reagentId;
+    }
+}
+
+/// <summary>
+///     Message to clear all filtered reagents.
+/// </summary>
+[Serializable, NetSerializable]
+public sealed class PlumbingFilterClearMessage : BoundUserInterfaceMessage;
diff --git a/Content.Shared/_Starlight/Plumbing/SharedPlumbingPillPress.cs b/Content.Shared/_Starlight/Plumbing/SharedPlumbingPillPress.cs
new file mode 100644
index 00000000000..ec74eaa47cb
--- /dev/null
+++ b/Content.Shared/_Starlight/Plumbing/SharedPlumbingPillPress.cs
@@ -0,0 +1,163 @@
+using Content.Shared.FixedPoint;
+using Robust.Shared.Serialization;
+
+namespace Content.Shared._Starlight.Plumbing;
+
+/// <summary>
+///     Whether the pill press produces pills or patches.
+/// </summary>
+[Serializable, NetSerializable]
+public enum PillPressOutputMode : byte
+{
+    Pill,
+    Patch,
+}
+
+/// <summary>
+///     UI key for the plumbing pill press interface.
+/// </summary>
+[Serializable, NetSerializable]
+public enum PlumbingPillPressUiKey : byte
+{
+    Key,
+}
+
+/// <summary>
+///     State sent to the client to update the pill press UI.
+/// </summary>
+[Serializable, NetSerializable]
+public sealed class PlumbingPillPressBoundUserInterfaceState : BoundUserInterfaceState
+{
+    public FixedPoint2 BufferVolume { get; }
+    public uint Dosage { get; }
+    public PillPressOutputMode OutputMode { get; }
+    public uint PillType { get; }
+    public bool Enabled { get; }
+
+    // Mixing mode fields
+    public bool MixingEnabled { get; }
+    public float InletRatioEast { get; }
+    public float InletRatioWest { get; }
+    public FixedPoint2 StagingEastVolume { get; }
+    public FixedPoint2 StagingWestVolume { get; }
+
+    public PlumbingPillPressBoundUserInterfaceState(
+        FixedPoint2 bufferVolume,
+        uint dosage,
+        PillPressOutputMode outputMode,
+        uint pillType,
+        bool enabled,
+        bool mixingEnabled,
+        float inletRatioEast,
+        float inletRatioWest,
+        FixedPoint2 stagingEastVolume,
+        FixedPoint2 stagingWestVolume)
+    {
+        BufferVolume = bufferVolume;
+        Dosage = dosage;
+        OutputMode = outputMode;
+        PillType = pillType;
+        Enabled = enabled;
+        MixingEnabled = mixingEnabled;
+        InletRatioEast = inletRatioEast;
+        InletRatioWest = inletRatioWest;
+        StagingEastVolume = stagingEastVolume;
+        StagingWestVolume = stagingWestVolume;
+    }
+}
+
+/// <summary>
+///     Message to toggle the pill press on/off.
+/// </summary>
+[Serializable, NetSerializable]
+public sealed class PlumbingPillPressToggleMessage : BoundUserInterfaceMessage
+{
+    public bool Enabled { get; }
+
+    public PlumbingPillPressToggleMessage(bool enabled)
+    {
+        Enabled = enabled;
+    }
+}
+
+/// <summary>
+///     Message to set the dosage (1–20).
+/// </summary>
+[Serializable, NetSerializable]
+public sealed class PlumbingPillPressSetDosageMessage : BoundUserInterfaceMessage
+{
+    public uint Dosage { get; }
+
+    public PlumbingPillPressSetDosageMessage(uint dosage)
+    {
+        Dosage = dosage;
+    }
+}
+
+/// <summary>
+///     Message to switch between pill and patch output.
+/// </summary>
+[Serializable, NetSerializable]
+public sealed class PlumbingPillPressSetOutputModeMessage : BoundUserInterfaceMessage
+{
+    public PillPressOutputMode OutputMode { get; }
+
+    public PlumbingPillPressSetOutputModeMessage(PillPressOutputMode outputMode)
+    {
+        OutputMode = outputMode;
+    }
+}
+
+/// <summary>
+///     Message to set the pill type visual (0–19).
+/// </summary>
+[Serializable, NetSerializable]
+public sealed class PlumbingPillPressSetPillTypeMessage : BoundUserInterfaceMessage
+{
+    public uint PillType { get; }
+
+    public PlumbingPillPressSetPillTypeMessage(uint pillType)
+    {
+        PillType = pillType;
+    }
+}
+
+/// <summary>
+///     Message to toggle mixing mode on/off.
+/// </summary>
+[Serializable, NetSerializable]
+public sealed class PlumbingPillPressSetMixingMessage : BoundUserInterfaceMessage
+{
+    public bool MixingEnabled { get; }
+
+    public PlumbingPillPressSetMixingMessage(bool mixingEnabled)
+    {
+        MixingEnabled = mixingEnabled;
+    }
+}
+
+/// <summary>
+///     Identifies which mixing inlet is being configured.
+/// </summary>
+[Serializable, NetSerializable]
+public enum PillPressInlet : byte
+{
+    East,
+    West,
+}
+
+/// <summary>
+///     Message to set the ratio for a mixing inlet.
+/// </summary>
+[Serializable, NetSerializable]
+public sealed class PlumbingPillPressSetInletRatioMessage : BoundUserInterfaceMessage
+{
+    public PillPressInlet Inlet { get; }
+    public float Ratio { get; }
+
+    public PlumbingPillPressSetInletRatioMessage(PillPressInlet inlet, float ratio)
+    {
+        Inlet = inlet;
+        Ratio = ratio;
+    }
+}
diff --git a/Content.Shared/_Starlight/Plumbing/SharedPlumbingReactor.cs b/Content.Shared/_Starlight/Plumbing/SharedPlumbingReactor.cs
new file mode 100644
index 00000000000..17abf48de30
--- /dev/null
+++ b/Content.Shared/_Starlight/Plumbing/SharedPlumbingReactor.cs
@@ -0,0 +1,131 @@
+using Content.Shared.FixedPoint;
+using Robust.Shared.Serialization;
+
+namespace Content.Shared._Starlight.Plumbing;
+
+/// <summary>
+///     UI key for the plumbing reactor interface.
+/// </summary>
+[Serializable, NetSerializable]
+public enum PlumbingReactorUiKey : byte
+{
+    Key,
+}
+
+/// <summary>
+///     State sent to the client to update the reactor UI.
+/// </summary>
+[Serializable, NetSerializable]
+public sealed class PlumbingReactorBoundUserInterfaceState : BoundUserInterfaceState
+{
+    /// <summary>
+    ///     The reagent targets the reactor is trying to accumulate.
+    ///     Key is reagent prototype ID, value is target quantity.
+    /// </summary>
+    public Dictionary<string, FixedPoint2> ReagentTargets { get; }
+
+    /// <summary>
+    ///     Current quantities of reagents in the buffer.
+    /// </summary>
+    public Dictionary<string, FixedPoint2> BufferContents { get; }
+
+    /// <summary>
+    ///     Current quantities of reagents in the output.
+    /// </summary>
+    public Dictionary<string, FixedPoint2> OutputContents { get; }
+
+    /// <summary>
+    ///     Whether the reactor is enabled.
+    /// </summary>
+    public bool Enabled { get; }
+
+    /// <summary>
+    ///     Target temperature for the buffer in Kelvin.
+    /// </summary>
+    public float TargetTemperature { get; }
+
+    /// <summary>
+    ///     Current temperature of the buffer in Kelvin.
+    /// </summary>
+    public float CurrentTemperature { get; }
+
+    public PlumbingReactorBoundUserInterfaceState(
+        Dictionary<string, FixedPoint2> reagentTargets,
+        Dictionary<string, FixedPoint2> bufferContents,
+        Dictionary<string, FixedPoint2> outputContents,
+        bool enabled,
+        float targetTemperature,
+        float currentTemperature)
+    {
+        ReagentTargets = reagentTargets;
+        BufferContents = bufferContents;
+        OutputContents = outputContents;
+        Enabled = enabled;
+        TargetTemperature = targetTemperature;
+        CurrentTemperature = currentTemperature;
+    }
+}
+
+/// <summary>
+///     Message to toggle the reactor on/off.
+/// </summary>
+[Serializable, NetSerializable]
+public sealed class PlumbingReactorToggleMessage : BoundUserInterfaceMessage
+{
+    public bool Enabled { get; }
+
+    public PlumbingReactorToggleMessage(bool enabled)
+    {
+        Enabled = enabled;
+    }
+}
+
+/// <summary>
+///     Message to set a reagent target quantity.
+/// </summary>
+[Serializable, NetSerializable]
+public sealed class PlumbingReactorSetTargetMessage : BoundUserInterfaceMessage
+{
+    public string ReagentId { get; }
+    public FixedPoint2 Quantity { get; }
+
+    public PlumbingReactorSetTargetMessage(string reagentId, FixedPoint2 quantity)
+    {
+        ReagentId = reagentId;
+        Quantity = quantity;
+    }
+}
+
+/// <summary>
+///     Message to remove a reagent target.
+/// </summary>
+[Serializable, NetSerializable]
+public sealed class PlumbingReactorRemoveTargetMessage : BoundUserInterfaceMessage
+{
+    public string ReagentId { get; }
+
+    public PlumbingReactorRemoveTargetMessage(string reagentId)
+    {
+        ReagentId = reagentId;
+    }
+}
+
+/// <summary>
+///     Message to clear all reagent targets.
+/// </summary>
+[Serializable, NetSerializable]
+public sealed class PlumbingReactorClearTargetsMessage : BoundUserInterfaceMessage;
+
+/// <summary>
+///     Message to set the target temperature.
+/// </summary>
+[Serializable, NetSerializable]
+public sealed class PlumbingReactorSetTemperatureMessage : BoundUserInterfaceMessage
+{
+    public float Temperature { get; }
+
+    public PlumbingReactorSetTemperatureMessage(float temperature)
+    {
+        Temperature = temperature;
+    }
+}
diff --git a/Content.Shared/_Starlight/Plumbing/SharedPlumbingSmartDispenser.cs b/Content.Shared/_Starlight/Plumbing/SharedPlumbingSmartDispenser.cs
new file mode 100644
index 00000000000..5b848fd6bcb
--- /dev/null
+++ b/Content.Shared/_Starlight/Plumbing/SharedPlumbingSmartDispenser.cs
@@ -0,0 +1,47 @@
+using System.Linq;
+using Content.Shared.FixedPoint;
+using Robust.Shared.Serialization;
+
+namespace Content.Shared._Starlight.Plumbing;
+
+[Serializable, NetSerializable]
+public enum PlumbingSmartDispenserUiKey : byte
+{
+    Key,
+}
+
+/// <summary>
+/// A single reagent entry for the plumbing smart dispenser UI.
+/// </summary>
+[Serializable, NetSerializable]
+public sealed class PlumbingSmartDispenserReagentEntry
+{
+    public string ReagentId;
+    public string LocalizedName;
+    public FixedPoint2 Quantity;
+    public Color Color;
+
+    public PlumbingSmartDispenserReagentEntry(string reagentId, string localizedName, FixedPoint2 quantity, Color color)
+    {
+        ReagentId = reagentId;
+        LocalizedName = localizedName;
+        Quantity = quantity;
+        Color = color;
+    }
+}
+
+/// <summary>
+/// BUI state sent to the client containing the current reagent inventory.
+/// </summary>
+[Serializable, NetSerializable]
+public sealed class PlumbingSmartDispenserBuiState : BoundUserInterfaceState
+{
+    public List<PlumbingSmartDispenserReagentEntry> Entries;
+    public float MaxPerReagent;
+
+    public PlumbingSmartDispenserBuiState(List<PlumbingSmartDispenserReagentEntry> entries, float maxPerReagent)
+    {
+        Entries = entries;
+        MaxPerReagent = maxPerReagent;
+    }
+}
diff --git a/Content.Shared/_Starlight/Plumbing/SharedPlumbingSynthesizer.cs b/Content.Shared/_Starlight/Plumbing/SharedPlumbingSynthesizer.cs
new file mode 100644
index 00000000000..36a57c6064c
--- /dev/null
+++ b/Content.Shared/_Starlight/Plumbing/SharedPlumbingSynthesizer.cs
@@ -0,0 +1,91 @@
+using Content.Shared.FixedPoint;
+using Robust.Shared.Serialization;
+
+namespace Content.Shared._Starlight.Plumbing;
+
+/// <summary>
+///     UI key for the plumbing synthesizer interface.
+/// </summary>
+[Serializable, NetSerializable]
+public enum PlumbingSynthesizerUiKey : byte
+{
+    Key,
+}
+
+/// <summary>
+///     State sent to the client to update the synthesizer UI.
+/// </summary>
+[Serializable, NetSerializable]
+public sealed class PlumbingSynthesizerBoundUserInterfaceState : BoundUserInterfaceState
+{
+    /// <summary>
+    ///     Available reagents that can be generated.
+    ///     Key is reagent prototype ID, value is power drain per unit.
+    /// </summary>
+    public Dictionary<string, float> GeneratableReagents { get; }
+
+    /// <summary>
+    ///     Currently selected reagent ID, or null if none selected.
+    /// </summary>
+    public string? SelectedReagent { get; }
+
+    /// <summary>
+    ///     Current contents of the buffer.
+    /// </summary>
+    public Dictionary<string, FixedPoint2> BufferContents { get; }
+
+    /// <summary>
+    ///     Whether the synthesizer is enabled.
+    /// </summary>
+    public bool Enabled { get; }
+
+    /// <summary>
+    ///     Current battery charge (0-1 ratio).
+    /// </summary>
+    public float BatteryCharge { get; }
+
+    public PlumbingSynthesizerBoundUserInterfaceState(
+        Dictionary<string, float> generatableReagents,
+        string? selectedReagent,
+        Dictionary<string, FixedPoint2> bufferContents,
+        bool enabled,
+        float batteryCharge)
+    {
+        GeneratableReagents = generatableReagents;
+        SelectedReagent = selectedReagent;
+        BufferContents = bufferContents;
+        Enabled = enabled;
+        BatteryCharge = batteryCharge;
+    }
+}
+
+/// <summary>
+///     Message to toggle the synthesizer on/off.
+/// </summary>
+[Serializable, NetSerializable]
+public sealed class PlumbingSynthesizerToggleMessage : BoundUserInterfaceMessage
+{
+    public bool Enabled { get; }
+
+    public PlumbingSynthesizerToggleMessage(bool enabled)
+    {
+        Enabled = enabled;
+    }
+}
+
+/// <summary>
+///     Message to select which reagent to generate.
+/// </summary>
+[Serializable, NetSerializable]
+public sealed class PlumbingSynthesizerSelectReagentMessage : BoundUserInterfaceMessage
+{
+    /// <summary>
+    ///     The reagent ID to select, or null to deselect.
+    /// </summary>
+    public string? ReagentId { get; }
+
+    public PlumbingSynthesizerSelectReagentMessage(string? reagentId)
+    {
+        ReagentId = reagentId;
+    }
+}
diff --git a/Resources/Locale/en-US/_Starlight/plumbing/pill-press.ftl b/Resources/Locale/en-US/_Starlight/plumbing/pill-press.ftl
new file mode 100644
index 00000000000..e3873966337
--- /dev/null
+++ b/Resources/Locale/en-US/_Starlight/plumbing/pill-press.ftl
@@ -0,0 +1,15 @@
+# Pill Press UI
+plumbing-pill-press-window-title = Plumbing Pill Press
+plumbing-pill-press-status = Status:
+plumbing-pill-press-enabled = Enabled
+plumbing-pill-press-disabled = Disabled
+plumbing-pill-press-output-mode = Output:
+plumbing-pill-press-mode-pill = Pills
+plumbing-pill-press-mode-patch = Patches
+plumbing-pill-press-dosage = Dosage (u):
+plumbing-pill-press-set = Set
+plumbing-pill-press-pill-type = Pill Type
+plumbing-pill-press-mixing-mode = Mixing Mode (E/W Inlets)
+plumbing-pill-press-east-ratio = East:
+plumbing-pill-press-west-ratio = West:
+
diff --git a/Resources/Locale/en-US/_Starlight/plumbing/plumbing.ftl b/Resources/Locale/en-US/_Starlight/plumbing/plumbing.ftl
new file mode 100644
index 00000000000..a52daa6b324
--- /dev/null
+++ b/Resources/Locale/en-US/_Starlight/plumbing/plumbing.ftl
@@ -0,0 +1,56 @@
+# Plumbing system localization
+
+plumbing-input-full = The input buffer is full!
+plumbing-input-poured = Poured {$amount}u into the plumbing network.
+
+plumbing-output-empty = The output buffer is empty!
+plumbing-output-filled = Filled container with {$amount}u from the plumbing network.
+
+# Reactor UI
+plumbing-reactor-window-title = Plumbing Reactor
+plumbing-reactor-status = Status:
+plumbing-reactor-enabled = Enabled
+plumbing-reactor-disabled = Disabled
+plumbing-reactor-temperature = Target Temp:
+plumbing-reactor-set = Set
+plumbing-reactor-reset = Reset
+plumbing-reactor-add-reagent = Add Reagent
+plumbing-reactor-reagent-id = Reagent ID
+plumbing-reactor-quantity = Quantity
+plumbing-reactor-add = Add
+plumbing-reactor-targets = Reaction Recipe
+plumbing-reactor-clear = Clear All
+plumbing-reactor-remove-selected = Remove Selected
+plumbing-reactor-output = Output Contents
+plumbing-reactor-invalid-reagent = Unknown reagent: {$reagent}
+
+# Filter UI
+plumbing-filter-window-title = Plumbing Filter
+plumbing-filter-status = Status:
+plumbing-filter-enabled = Enabled
+plumbing-filter-disabled = Disabled
+plumbing-filter-add-reagent = Add Reagent to Filter
+plumbing-filter-reagent-id = Reagent ID
+plumbing-filter-add = Add
+plumbing-filter-filtered = Filtered Reagents
+plumbing-filter-clear = Clear All
+plumbing-filter-remove-selected = Remove Selected
+plumbing-filter-invalid-reagent = Unknown reagent: {$reagent}
+
+# Synthesizer UI
+plumbing-synthesizer-window-title = Plumbing Synthesizer
+plumbing-synthesizer-status = Status:
+plumbing-synthesizer-enabled = Enabled
+plumbing-synthesizer-disabled = Disabled
+plumbing-synthesizer-battery = Battery:
+plumbing-synthesizer-power = Power:
+plumbing-synthesizer-power-on = Connected
+plumbing-synthesizer-power-off = No Power
+plumbing-synthesizer-select-reagent = Select Reagent
+plumbing-synthesizer-none = None
+plumbing-synthesizer-buffer = Buffer Contents
+plumbing-synthesizer-buffer-empty = Empty
+
+# Plunger drain
+plumbing-drain-success = Drained {$amount}u onto the floor.
+plumbing-drain-empty = Nothing to drain.
diff --git a/Resources/Locale/en-US/_Starlight/plumbing/smart-dispenser.ftl b/Resources/Locale/en-US/_Starlight/plumbing/smart-dispenser.ftl
new file mode 100644
index 00000000000..d00b6d6f14f
--- /dev/null
+++ b/Resources/Locale/en-US/_Starlight/plumbing/smart-dispenser.ftl
@@ -0,0 +1,10 @@
+plumbing-smart-dispenser-window-title = Smart Dispenser
+plumbing-smart-dispenser-header = Chemical Storage
+plumbing-smart-dispenser-reagent-entry = {$reagent}: {$amount}u
+plumbing-smart-dispenser-empty = No reagents stored.
+plumbing-smart-dispenser-total = {$count} reagent(s) — {$total}u total
+plumbing-smart-dispenser-no-label = Container has no label.
+plumbing-smart-dispenser-no-match = Could not match label to any known reagent.
+plumbing-smart-dispenser-not-in-stock = {$reagent} is not in stock.
+plumbing-smart-dispenser-jug-full = Container is already full.
+plumbing-smart-dispenser-filled = Filled {$amount}u of {$reagent}.
diff --git a/Resources/Prototypes/_StarLight/Entities/Structures/Piping/Plumbing/ducts.yml b/Resources/Prototypes/_StarLight/Entities/Structures/Piping/Plumbing/ducts.yml
new file mode 100644
index 00000000000..8de7c5f5869
--- /dev/null
+++ b/Resources/Prototypes/_StarLight/Entities/Structures/Piping/Plumbing/ducts.yml
@@ -0,0 +1,189 @@
+# ============================================================================
+# Plumbing Ducts
+# ============================================================================
+# Ducts allow transport of reagents through the plumbing network.
+# All ducts inherit from PlumbingDuctBase for common components.
+# ============================================================================
+
+# ============================================================================
+# BASE ENTITY
+# ============================================================================
+
+- type: entity
+  abstract: true
+  parent: BaseItem
+  id: PlumbingDuctBase
+  name: fluid duct
+  description: A duct for transporting reagents through the plumbing network.
+  placement:
+    mode: SnapgridCenter
+  components:
+  - type: Visibility
+    layer: 1
+  - type: Item
+    size: Normal
+  - type: Transform
+    anchored: true
+  - type: Sprite
+    sprite: _Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi
+    drawdepth: ThinPipe
+    visible: false
+  - type: Appearance
+  - type: PipeAppearance
+    sprite:
+    - sprite: _Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi
+      state: ductConnector
+  - type: PipeColorVisuals
+  - type: AtmosPipeColor
+  - type: Clickable
+  - type: InteractionOutline
+  - type: SubFloorHide
+  - type: CollideOnAnchor
+  - type: Anchorable
+  - type: Pullable
+  - type: Rotatable
+  - type: NodeContainer
+  - type: Tag
+    tags:
+    - PlumbingDuct
+  - type: Physics
+    canCollide: false
+    bodyType: static
+  - type: Damageable
+    damageContainer: StructuralInorganic
+    damageModifierSet: Metallic
+  - type: Destructible
+    thresholds:
+    - trigger:
+        !type:DamageTrigger
+        damage: 200
+      behaviors:
+      - !type:DoActsBehavior
+        acts: ["Destruction"]
+    - trigger:
+        !type:DamageTrigger
+        damage: 100
+      behaviors:
+      - !type:PlaySoundBehavior
+        sound:
+          collection: MetalBreak
+          params:
+            volume: -8
+      - !type:DoActsBehavior
+        acts: [Breakage]
+  - type: PipeRestrictOverlap
+  - type: RCDDeconstructable
+    cost: 1
+    delay: 2
+    fx: EffectRCDDeconstruct2
+    rpld: true
+  - type: StaticPrice
+    price: 20
+
+# ============================================================================
+# DUCT VARIANTS
+# ============================================================================
+
+# --------------------------------
+# Straight Duct
+# --------------------------------
+- type: entity
+  parent: PlumbingDuctBase
+  id: PlumbingDuctStraight
+  name: fluid duct
+  suffix: Straight
+  components:
+  - type: NodeContainer
+    nodes:
+      duct:
+        !type:PlumbingNode
+        nodeGroupID: Plumbing
+        pipeDirection: Longitudinal
+  - type: Sprite
+    layers:
+    - state: ductStraight
+      map: [ "enum.PipeVisualLayers.Pipe" ]
+      color: "#4169E1"
+  - type: Item
+    storedSprite:
+      sprite: _Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi
+      state: storageStraight
+    shape:
+    - 0,0,0,2
+
+# --------------------------------
+# Bend Duct
+# --------------------------------
+- type: entity
+  parent: PlumbingDuctBase
+  id: PlumbingDuctBend
+  name: fluid duct
+  suffix: Bend
+  components:
+  - type: NodeContainer
+    nodes:
+      duct:
+        !type:PlumbingNode
+        nodeGroupID: Plumbing
+        pipeDirection: SWBend
+  - type: Sprite
+    layers:
+    - state: ductBend
+      map: [ "enum.PipeVisualLayers.Pipe" ]
+      color: "#4169E1"
+  - type: Item
+    size: Small
+    storedSprite:
+      sprite: _Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi
+      state: storageBend
+
+# --------------------------------
+# T-Junction Duct
+# --------------------------------
+- type: entity
+  parent: PlumbingDuctBase
+  id: PlumbingDuctTJunction
+  name: fluid duct
+  suffix: T-Junction
+  components:
+  - type: NodeContainer
+    nodes:
+      duct:
+        !type:PlumbingNode
+        nodeGroupID: Plumbing
+        pipeDirection: TSouth
+  - type: Sprite
+    layers:
+    - state: ductTJunction
+      map: [ "enum.PipeVisualLayers.Pipe" ]
+      color: "#4169E1"
+  - type: Item
+    storedSprite:
+      sprite: _Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi
+      state: storageTjunction
+
+# --------------------------------
+# Fourway Duct
+# --------------------------------
+- type: entity
+  parent: PlumbingDuctBase
+  id: PlumbingDuctFourway
+  name: fluid duct
+  suffix: Fourway
+  components:
+  - type: NodeContainer
+    nodes:
+      duct:
+        !type:PlumbingNode
+        nodeGroupID: Plumbing
+        pipeDirection: Fourway
+  - type: Sprite
+    layers:
+    - state: ductFourway
+      map: [ "enum.PipeVisualLayers.Pipe" ]
+      color: "#4169E1"
+  - type: Item
+    size: Small
+    storedSprite:
+      sprite: _Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi
+      state: storageFourway
diff --git a/Resources/Prototypes/_StarLight/Entities/Structures/Piping/Plumbing/patch.yml b/Resources/Prototypes/_StarLight/Entities/Structures/Piping/Plumbing/patch.yml
new file mode 100644
index 00000000000..a507b07d71e
--- /dev/null
+++ b/Resources/Prototypes/_StarLight/Entities/Structures/Piping/Plumbing/patch.yml
@@ -0,0 +1,27 @@
+# Minimal Patch entity for use with the Plumbing Pill Press machine.
+# Produced by PlumbingPillPress when set to Patch output mode.
+
+- type: entity
+  abstract: true
+  parent: BaseHealingItem
+  id: BasePatch
+  name: patch
+  description: On-touch administration of chemicals.
+  components:
+  - type: Item
+    size: Small
+  - type: SolutionContainerManager
+    solutions:
+      patch:
+        maxVol: 20
+  - type: Patch
+  - type: Tag
+    tags:
+      - Patch
+  - type: Extractable
+    grindableSolutionName: patch
+
+- type: entity
+  parent: BasePatch
+  id: Patch
+  suffix: Empty
diff --git a/Resources/Prototypes/_StarLight/Entities/Structures/Piping/Plumbing/plumbing_machines.yml b/Resources/Prototypes/_StarLight/Entities/Structures/Piping/Plumbing/plumbing_machines.yml
new file mode 100644
index 00000000000..0026ef03a7b
--- /dev/null
+++ b/Resources/Prototypes/_StarLight/Entities/Structures/Piping/Plumbing/plumbing_machines.yml
@@ -0,0 +1,780 @@
+# Base plumbing machine entity - all plumbing machines inherit from this
+- type: entity
+  abstract: true
+  id: PlumbingMachineBase
+  placement:
+    mode: SnapgridCenter
+  components:
+  - type: Transform
+    anchored: true
+    noRot: false
+  - type: Sprite
+    noRot: false  # Allow rotation so connectors face correct direction
+  - type: Clickable
+  - type: Appearance
+  - type: PlumbingConnectorAppearance
+    offset: 0.09375
+  - type: InteractionOutline
+  - type: Anchorable
+  - type: Pullable
+  - type: Rotatable
+    rotateWhileAnchored: true
+  - type: Physics
+    bodyType: Static
+  - type: Fixtures
+    fixtures:
+      fix1:
+        shape:
+          !type:PhysShapeAabb
+          bounds: -0.25,-0.25,0.25,0.25
+        density: 190
+        mask:
+        - MachineMask
+        layer:
+        - MachineLayer
+  - type: AtmosPipeColor
+  - type: RCDDeconstructable
+    cost: 2
+    delay: 2
+    fx: EffectRCDDeconstruct2
+    rpld: true
+  - type: Damageable
+    damageContainer: StructuralInorganic
+    damageModifierSet: Metallic
+
+# =============================================================================
+# Plumbing Tank - stores reagents in the network
+# =============================================================================
+- type: entity
+  parent: PlumbingMachineBase
+  id: PlumbingTank
+  name: Plumbing Tank
+  description: Stores up to 2000u of reagents. Use tanks to buffer reagents between production stages or just store large amounts of reagents.
+  components:
+  - type: Sprite
+    sprite: _Starlight/Structures/Piping/Plumbing/plumbers.rsi
+    layers:
+    - state: tank
+  - type: PlumbingDevice
+    updateInterval: 2
+  - type: PlumbingInlet
+    solutionName: tank
+  - type: Plungeable
+  - type: PlumbingOutlet
+    solutionName: tank
+  - type: SolutionContainerManager
+    solutions:
+      tank:
+        maxVol: 2000
+        canReact: false
+  - type: ExaminableSolution
+    solution: tank
+  - type: NodeContainer
+    nodes:
+      inlet:
+        !type:PlumbingNode
+        nodeGroupID: Plumbing
+        pipeDirection: North
+      outlet:
+        !type:PlumbingNode
+        nodeGroupID: Plumbing
+        pipeDirection: TSouth
+  - type: Destructible
+    thresholds:
+    - trigger:
+        !type:DamageTrigger
+        damage: 100
+      behaviors:
+      - !type:SpillBehavior
+        solution: tank
+      - !type:DoActsBehavior
+        acts: ["Destruction"]
+  - type: StaticPrice
+    price: 100
+
+# =============================================================================
+# Plumbing Input - pour reagents into the network
+# =============================================================================
+- type: entity
+  parent: PlumbingMachineBase
+  id: PlumbingInput
+  name: Plumbing Input
+  description: A small tank you pour reagents into. Other machines pull from this. Connects in all directions.
+  components:
+  - type: Physics
+    bodyType: Static
+    canCollide: false
+  - type: Fixtures
+    fixtures: {}
+  - type: Sprite
+    sprite: _Starlight/Structures/Piping/Plumbing/plumbers.rsi
+    layers:
+    - state: pipe_input
+  - type: PlumbingInput
+    solutionName: input
+  - type: Plungeable
+  - type: PlumbingOutlet
+    solutionName: input
+  - type: SolutionContainerManager
+    solutions:
+      input:
+        maxVol: 100
+        canReact: false
+  - type: ExaminableSolution
+    solution: input
+  - type: NodeContainer
+    nodes:
+      outlet:
+        !type:PlumbingNode
+        nodeGroupID: Plumbing
+        pipeDirection: Fourway
+  - type: Destructible
+    thresholds:
+    - trigger:
+        !type:DamageTrigger
+        damage: 100
+      behaviors:
+      - !type:SpillBehavior
+        solution: input
+      - !type:DoActsBehavior
+        acts: ["Destruction"]
+  - type: StaticPrice
+    price: 75
+
+# =============================================================================
+# Plumbing Sink - draws reagents from the network, has an outlet for solutions dumped into it
+# =============================================================================
+- type: entity
+  parent: PlumbingMachineBase
+  id: PlumbingSink
+  name: Plumbing Sink
+  description: A sink connected to the plumbing network. Draw reagents from it with a container, or dump reagents into it to send them down the drain. Connects in all directions.
+  components:
+  - type: Sprite
+    sprite: Structures/Furniture/sink.rsi
+    drawdepth: FloorObjects
+    layers:
+    - state: sink_wide
+  - type: Rotatable
+    rotateWhileAnchored: false
+  - type: PlumbingDevice
+    updateInterval: 2
+  - type: PlumbingInlet
+    solutionName: output
+    inletNames:
+    - inletNorth
+    - inletEast
+    - inletWest
+  - type: PlumbingOutput
+    solutionName: output
+  - type: PlumbingOutlet
+    solutionName: drain
+  - type: DumpableSolution
+    solution: drain
+  - type: Plungeable
+  - type: SolutionContainerManager
+    solutions:
+      output:
+        maxVol: 100
+        canReact: false
+      drain:
+        maxVol: 100
+        canReact: false
+  - type: ExaminableSolution
+    solution: output
+  - type: NodeContainer
+    nodes:
+      inletNorth:
+        !type:PlumbingNode
+        nodeGroupID: Plumbing
+        pipeDirection: North
+      inletEast:
+        !type:PlumbingNode
+        nodeGroupID: Plumbing
+        pipeDirection: East
+      inletWest:
+        !type:PlumbingNode
+        nodeGroupID: Plumbing
+        pipeDirection: West
+      outlet:
+        !type:PlumbingNode
+        nodeGroupID: Plumbing
+        pipeDirection: South
+  - type: Destructible
+    thresholds:
+    - trigger:
+        !type:DamageTrigger
+        damage: 100
+      behaviors:
+      - !type:SpillBehavior
+        solution: output
+      - !type:SpillBehavior
+        solution: drain
+      - !type:DoActsBehavior
+        acts: ["Destruction"]
+  - type: StaticPrice
+    price: 100
+
+# =============================================================================
+# Plumbing Output - draw reagents from the network
+# =============================================================================
+- type: entity
+  parent: PlumbingMachineBase
+  id: PlumbingOutput
+  name: Plumbing Output
+  description: A small tank that pulls reagents from the network. Draw from it with a container. Connects in all directions.
+  components:
+  - type: Physics
+    bodyType: Static
+    canCollide: false
+  - type: Fixtures
+    fixtures: {}
+  - type: Sprite
+    sprite: _Starlight/Structures/Piping/Plumbing/plumbers.rsi
+    layers:
+    - state: pipe_output
+  - type: PlumbingDevice
+    updateInterval: 2
+  - type: PlumbingInlet
+    solutionName: output
+    inletNames:
+    - inletNorth
+    - inletEast
+    - inletSouth
+    - inletWest
+  - type: PlumbingOutput
+    solutionName: output
+  - type: Plungeable
+  - type: SolutionContainerManager
+    solutions:
+      output:
+        maxVol: 100
+        canReact: false
+  - type: ExaminableSolution
+    solution: output
+  - type: NodeContainer
+    nodes:
+      inletNorth:
+        !type:PlumbingNode
+        nodeGroupID: Plumbing
+        pipeDirection: North
+      inletEast:
+        !type:PlumbingNode
+        nodeGroupID: Plumbing
+        pipeDirection: East
+      inletSouth:
+        !type:PlumbingNode
+        nodeGroupID: Plumbing
+        pipeDirection: South
+      inletWest:
+        !type:PlumbingNode
+        nodeGroupID: Plumbing
+        pipeDirection: West
+  - type: Destructible
+    thresholds:
+    - trigger:
+        !type:DamageTrigger
+        damage: 100
+      behaviors:
+      - !type:SpillBehavior
+        solution: output
+      - !type:DoActsBehavior
+        acts: ["Destruction"]
+  - type: StaticPrice
+    price: 75
+
+# =============================================================================
+# Plumbing Reactor - accumulates reagents and triggers reactions
+# =============================================================================
+- type: entity
+  parent: PlumbingMachineBase
+  id: PlumbingReactor
+  name: Plumbing Reactor
+  description: Pulls target reagents in up to configured quantities from its inlet and triggers reactions. Requires power.
+  components:
+  - type: Sprite
+    sprite: _Starlight/Structures/Piping/Plumbing/plumbers.rsi
+    layers:
+    - state: reaction_chamber
+      map: [ "enum.PlumbingVisualLayers.Base" ]
+  - type: GenericVisualizer
+    visuals:
+      enum.PlumbingVisuals.Running:
+        enum.PlumbingVisualLayers.Base:
+          True: { state: reaction_chamber_on }
+          False: { state: reaction_chamber }
+  - type: PlumbingDevice
+    updateInterval: 2
+  - type: PlumbingReactor
+    bufferSolutionName: buffer
+    outputSolutionName: output
+    inletName: inlet
+  - type: Plungeable
+  - type: PlumbingOutlet
+    solutionName: output
+  - type: SolutionContainerManager
+    solutions:
+      buffer:
+        maxVol: 100
+        canReact: false  # Reactions triggered manually when targets met
+      output:
+        maxVol: 100
+        canReact: false
+  - type: ExaminableSolution
+    solution: output
+  - type: NodeContainer
+    nodes:
+      inlet:
+        !type:PlumbingNode
+        nodeGroupID: Plumbing
+        pipeDirection: North
+      outlet:
+        !type:PlumbingNode
+        nodeGroupID: Plumbing
+        pipeDirection: South
+  - type: UserInterface
+    interfaces:
+      enum.PlumbingReactorUiKey.Key:
+        type: PlumbingReactorBoundUserInterface
+  - type: ActivatableUI
+    key: enum.PlumbingReactorUiKey.Key
+  - type: ApcPowerReceiver
+    powerLoad: 750
+  - type: ExtensionCableReceiver
+  - type: Destructible
+    thresholds:
+    - trigger:
+        !type:DamageTrigger
+        damage: 100
+      behaviors:
+      - !type:SpillBehavior
+        solution: buffer
+      - !type:SpillBehavior
+        solution: output
+      - !type:DoActsBehavior
+        acts: ["Destruction"]
+  - type: StaticPrice
+    price: 150
+
+# =============================================================================
+# Plumbing Smart Dispenser - stores reagents from the network, fills labeled jugs
+# =============================================================================
+- type: entity
+  parent: PlumbingMachineBase
+  id: PlumbingSmartDispenser
+  name: Plumbing Smart Dispenser
+  description: Pulls in all reagents from its inlets and stores up to 200u of each type. Use a labeled jug on the dispenser to fill it with the matching reagent. Requires power.
+  components:
+  - type: Sprite
+    sprite: Structures/Machines/smartfridge.rsi
+    layers:
+    - state: smartfridge
+      map: ["enum.StorageVisualLayers.Base"]
+    - state: smartfridge_door
+      map: ["enum.StorageVisualLayers.Door"]
+      shader: unshaded
+  - type: PointLight
+    radius: 1.2
+    energy: 3.0
+    color: "#9dc5c9"
+  - type: PlumbingDevice
+    updateInterval: 2
+  - type: PlumbingInlet
+    solutionName: fridge
+    inletNames:
+    - inletNorth
+    - inletEast
+    - inletSouth
+    - inletWest
+  - type: PlumbingSmartDispenser
+    solutionName: fridge
+    maxPerReagent: 200
+  - type: SolutionContainerManager
+    solutions:
+      fridge:
+        maxVol: 50000
+        canReact: false
+  - type: ExaminableSolution
+    solution: fridge
+  - type: NodeContainer
+    nodes:
+      inletNorth:
+        !type:PlumbingNode
+        nodeGroupID: Plumbing
+        pipeDirection: North
+      inletEast:
+        !type:PlumbingNode
+        nodeGroupID: Plumbing
+        pipeDirection: East
+      inletSouth:
+        !type:PlumbingNode
+        nodeGroupID: Plumbing
+        pipeDirection: South
+      inletWest:
+        !type:PlumbingNode
+        nodeGroupID: Plumbing
+        pipeDirection: West
+  - type: UserInterface
+    interfaces:
+      enum.PlumbingSmartDispenserUiKey.Key:
+        type: PlumbingSmartDispenserBoundUserInterface
+  - type: ActivatableUI
+    key: enum.PlumbingSmartDispenserUiKey.Key
+  - type: ApcPowerReceiver
+    powerLoad: 200
+  - type: ExtensionCableReceiver
+  - type: Destructible
+    thresholds:
+    - trigger:
+        !type:DamageTrigger
+        damage: 200
+      behaviors:
+      - !type:SpillBehavior
+        solution: fridge
+      - !type:DoActsBehavior
+        acts: ["Destruction"]
+  - type: StaticPrice
+    price: 200
+
+# =============================================================================
+# Plumbing Pill Press - automatically creates pills or patches from reagents
+# =============================================================================
+- type: entity
+  parent: PlumbingMachineBase
+  id: PlumbingPillPress
+  name: Plumbing Pill Press
+  description: Pulls in reagents and presses them into pills or patches at a configurable dosage. Has optional mixing inlets for ratio-controlled mixing. Requires power.
+  components:
+  - type: Sprite
+    sprite: _Starlight/Structures/Piping/Plumbing/plumbers.rsi
+    layers:
+    - state: pill_press_off
+      map: [ "enum.PlumbingVisualLayers.Base" ]
+  - type: GenericVisualizer
+    visuals:
+      enum.PlumbingVisuals.Running:
+        enum.PlumbingVisualLayers.Base:
+          True: { state: pill_press }
+          False: { state: pill_press_off }
+  - type: PlumbingDevice
+    updateInterval: 2
+  - type: PlumbingPillPress
+    bufferSolutionName: buffer
+    dosage: 10
+  - type: PlumbingConnectorAppearance
+    offset: 0.09375
+    mixingInletNames:
+    - mixingInletEast
+    - mixingInletWest
+  - type: PlumbingInlet
+    solutionName: buffer
+    inletNames:
+    - inlet
+  - type: SolutionContainerManager
+    solutions:
+      buffer:
+        maxVol: 20
+        canReact: false
+      stagingEast:
+        maxVol: 20
+        canReact: false
+      stagingWest:
+        maxVol: 20
+        canReact: false
+  - type: ExaminableSolution
+    solution: buffer
+  - type: NodeContainer
+    nodes:
+      inlet:
+        !type:PlumbingNode
+        nodeGroupID: Plumbing
+        pipeDirection: North
+      mixingInletEast:
+        !type:PlumbingNode
+        nodeGroupID: Plumbing
+        pipeDirection: East
+      mixingInletWest:
+        !type:PlumbingNode
+        nodeGroupID: Plumbing
+        pipeDirection: West
+  - type: UserInterface
+    interfaces:
+      enum.PlumbingPillPressUiKey.Key:
+        type: PlumbingPillPressBoundUserInterface
+  - type: ActivatableUI
+    key: enum.PlumbingPillPressUiKey.Key
+  - type: ApcPowerReceiver
+    powerLoad: 200
+  - type: ExtensionCableReceiver
+  - type: Destructible
+    thresholds:
+    - trigger:
+        !type:DamageTrigger
+        damage: 100
+      behaviors:
+      - !type:SpillBehavior
+        solution: buffer
+      - !type:DoActsBehavior
+        acts: ["Destruction"]
+  - type: StaticPrice
+    price: 150
+# =============================================================================
+# Plumbing Filter - separates specific reagents into two outputs
+# =============================================================================
+- type: entity
+  parent: PlumbingMachineBase
+  id: PlumbingFilter
+  name: Plumbing Filter
+  description: Filters specific reagents from a duct network. Filtered reagents are sent to the side outlet while other reagents passthrough.
+  components:
+  - type: Physics
+    bodyType: Static
+    canCollide: false
+  - type: Fixtures
+    fixtures: {}
+  - type: Sprite
+    sprite: _Starlight/Structures/Piping/Plumbing/plumbers.rsi
+    layers:
+    - state: filter
+  - type: PlumbingDevice
+    updateInterval: 2
+  - type: PlumbingInlet
+    solutionName: buffer
+  - type: PlumbingFilter
+    filterNodeName: outletFilter
+    passthroughNodeName: outletPassthrough
+    bufferSolutionName: buffer
+  - type: Plungeable
+  - type: PlumbingOutlet
+    solutionName: buffer
+    outletNames:
+    - outletFilter
+    - outletPassthrough
+  - type: SolutionContainerManager
+    solutions:
+      buffer:
+        maxVol: 40
+        canReact: false
+  - type: ExaminableSolution
+    solution: buffer
+  - type: NodeContainer
+    nodes:
+      inlet:
+        !type:PlumbingNode
+        nodeGroupID: Plumbing
+        pipeDirection: North
+      outletFilter:
+        !type:PlumbingNode
+        nodeGroupID: Plumbing
+        pipeDirection: West
+      outletPassthrough:
+        !type:PlumbingNode
+        nodeGroupID: Plumbing
+        pipeDirection: South
+  - type: AtmosPipeColor
+    color: "#8B4513"
+  - type: UserInterface
+    interfaces:
+      enum.PlumbingFilterUiKey.Key:
+        type: PlumbingFilterBoundUserInterface
+  - type: ActivatableUI
+    key: enum.PlumbingFilterUiKey.Key
+  - type: Flippable
+    mirrorEntity: PlumbingFilterFlipped
+  - type: Destructible
+    thresholds:
+    - trigger:
+        !type:DamageTrigger
+        damage: 100
+      behaviors:
+      - !type:SpillBehavior
+        solution: buffer
+      - !type:DoActsBehavior
+        acts: ["Destruction"]
+  - type: StaticPrice
+    price: 125
+
+- type: entity
+  parent: PlumbingFilter
+  id: PlumbingFilterFlipped
+  suffix: Flipped
+  description: Filters specific reagents from a duct network. Filtered reagents are sent to the side outlet while other reagents passthrough.
+  components:
+  - type: Physics
+    bodyType: Static
+    canCollide: false
+  - type: Fixtures
+    fixtures: {}
+  - type: Sprite
+    sprite: _Starlight/Structures/Piping/Plumbing/plumbers.rsi
+    layers:
+    - state: filterF
+  - type: NodeContainer
+    nodes:
+      inlet:
+        !type:PlumbingNode
+        nodeGroupID: Plumbing
+        pipeDirection: South
+      outletFilter:
+        !type:PlumbingNode
+        nodeGroupID: Plumbing
+        pipeDirection: West
+      outletPassthrough:
+        !type:PlumbingNode
+        nodeGroupID: Plumbing
+        pipeDirection: North
+  - type: Flippable
+    mirrorEntity: PlumbingFilter
+
+# =============================================================================
+# Plumbing Synthesizer - generates reagents from power
+# =============================================================================
+- type: entity
+  parent: PlumbingMachineBase
+  id: PlumbingSynthesizer
+  name: Plumbing Synthesizer
+  description: Generates basic reagents using power from an internal battery.
+  components:
+  - type: Sprite
+    sprite: _Starlight/Structures/Piping/Plumbing/plumbers.rsi
+    noRot: false
+    layers:
+    - state: synthesizer
+    - state: synthesizer_overlay
+      map: [ "enum.PlumbingVisualLayers.Overlay" ]
+      visible: false
+  - type: GenericVisualizer
+    visuals:
+      enum.PlumbingVisuals.Running:
+        enum.PlumbingVisualLayers.Overlay:
+          True: { visible: true }
+          False: { visible: false }
+  - type: PlumbingDevice
+    updateInterval: 2
+  - type: PlumbingSynthesizer
+    bufferSolutionName: buffer
+    generatableReagents:
+      Iron: 2
+      Carbon: 2
+      Copper: 2
+      Hydrogen: 2
+      Oxygen: 0
+      Sugar: 2
+      Silicon: 5
+      Phosphorus: 5
+  - type: Plungeable
+  - type: PlumbingOutlet
+    solutionName: buffer
+  - type: SolutionContainerManager
+    solutions:
+      buffer:
+        maxVol: 10
+        canReact: false
+  - type: ExaminableSolution
+    solution: buffer
+  - type: NodeContainer
+    nodes:
+      outlet:
+        !type:PlumbingNode
+        nodeGroupID: Plumbing
+        pipeDirection: TSouth
+  - type: UserInterface
+    interfaces:
+      enum.PlumbingSynthesizerUiKey.Key:
+        type: PlumbingSynthesizerBoundUserInterface
+  - type: ActivatableUI
+    key: enum.PlumbingSynthesizerUiKey.Key
+  - type: PowerCellSlot
+    cellSlotId: cell_slot
+  - type: ItemSlots
+    slots:
+      cell_slot:
+        name: power-cell-slot-component-slot-name-default
+        startingItem: PowerCellMedium
+  - type: ContainerContainer
+    containers:
+      cell_slot: !type:ContainerSlot
+  - type: Charger
+    slotId: cell_slot
+    chargeRate: 5
+    passiveDraw: 1
+  - type: ApcPowerReceiver
+    powerLoad: 1
+  - type: ExtensionCableReceiver
+  - type: Destructible
+    thresholds:
+    - trigger:
+        !type:DamageTrigger
+        damage: 100
+      behaviors:
+      - !type:SpillBehavior
+        solution: buffer
+      - !type:DoActsBehavior
+        acts: ["Destruction"]
+  - type: StaticPrice
+    price: 200
+# =============================================================================
+# Plumbing Drain - floor drain that outputs to plumbing network
+# =============================================================================
+- type: entity
+  parent: PlumbingMachineBase
+  id: PlumbingDrain
+  name: Plumbing Drain
+  description: A floor drain that absorbs puddles and routes them into the plumbing network instead of disposing them.
+  placement:
+    mode: SnapgridCenter
+  components:
+  - type: Sprite
+    drawdepth: FloorObjects
+    sprite: Objects/Specific/Janitorial/drain.rsi
+    layers:
+    - state: icon
+    - map: [ "enum.SolutionContainerLayers.Fill" ]
+      state: fill-1
+      visible: false
+  - type: Physics
+    bodyType: Static
+    canCollide: false
+  - type: Fixtures
+    fixtures: {}
+  - type: AmbientSound
+    enabled: false
+    volume: -8
+    range: 8
+    sound:
+      path: /Audio/Ambience/Objects/drain.ogg
+  - type: Drain
+    unitsDestroyedPerSecond: 0
+  - type: DumpableSolution
+    solution: drainBuffer
+  - type: Appearance
+  - type: SolutionContainerVisuals
+    maxFillLevels: 1
+    fillBaseName: fill-
+    solutionName: drainBuffer
+  - type: PlumbingOutlet
+    solutionName: drainBuffer
+  - type: SolutionContainerManager
+    solutions:
+      drainBuffer:
+        maxVol: 400
+  - type: NodeContainer
+    nodes:
+      outlet:
+        !type:PlumbingNode
+        nodeGroupID: Plumbing
+        pipeDirection: Fourway
+  - type: ExaminableSolution
+    solution: drainBuffer
+  - type: Destructible
+    thresholds:
+    - trigger:
+        !type:DamageTrigger
+        damage: 100
+      behaviors:
+      - !type:SpillBehavior
+        solution: drainBuffer
+      - !type:DoActsBehavior
+        acts: ["Destruction"]
+  - type: StaticPrice
+    price: 150
diff --git a/Resources/Prototypes/tags.yml b/Resources/Prototypes/tags.yml
index be627a89591..f203126383b 100644
--- a/Resources/Prototypes/tags.yml
+++ b/Resources/Prototypes/tags.yml
@@ -1590,3 +1590,11 @@
 ## Y ##
 ## Z ##
 # ALPHABETICAL
+
+## Starlight Plumbing ##
+
+- type: Tag
+  id: Patch
+
+- type: Tag
+  id: PlumbingDuct
diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi/ductBend.png b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi/ductBend.png
new file mode 100644
index 00000000000..5c56208d548
Binary files /dev/null and b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi/ductBend.png differ
diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi/ductConnector.png b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi/ductConnector.png
new file mode 100644
index 00000000000..597a7f2fe58
Binary files /dev/null and b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi/ductConnector.png differ
diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi/ductFourway.png b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi/ductFourway.png
new file mode 100644
index 00000000000..e920791d890
Binary files /dev/null and b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi/ductFourway.png differ
diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi/ductStraight.png b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi/ductStraight.png
new file mode 100644
index 00000000000..00033a3df21
Binary files /dev/null and b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi/ductStraight.png differ
diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi/ductTJunction.png b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi/ductTJunction.png
new file mode 100644
index 00000000000..199b7859086
Binary files /dev/null and b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi/ductTJunction.png differ
diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi/meta.json b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi/meta.json
new file mode 100644
index 00000000000..7e588ca19cf
--- /dev/null
+++ b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi/meta.json
@@ -0,0 +1,52 @@
+{
+    "version": 1,
+    "license": "CC-BY-SA-3.0",
+    "copyright": "TGstation",
+    "size": {
+        "x": 32,
+        "y": 32
+    },
+    "states": [
+        {
+            "name": "ductBend",
+            "directions": 4,
+            "copyright": "TGStation"
+        },
+        {
+            "name": "ductConnector",
+            "directions": 4,
+            "copyright": "TGStation"
+        },
+        {
+            "name": "ductFourway",
+            "directions": 4,
+            "copyright": "TGStation"
+        },
+        {
+            "name": "ductStraight",
+            "directions": 4,
+            "copyright": "TGStation"
+        },
+        {
+            "name": "ductTJunction",
+            "directions": 4,
+            "copyright": "TGStation"
+        },
+        {
+            "name": "storageBend",
+            "copyright": "TGStation"
+        },
+        {
+            "name": "storageFourway",
+            "copyright": "TGStation"
+        },
+        {
+            "name": "storageStraight",
+            "copyright": "TGStation"
+        },
+        {
+            "name": "storageTjunction",
+            "copyright": "TGStation"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi/storageBend.png b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi/storageBend.png
new file mode 100644
index 00000000000..0fb7161e186
Binary files /dev/null and b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi/storageBend.png differ
diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi/storageFourway.png b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi/storageFourway.png
new file mode 100644
index 00000000000..3b915b5918e
Binary files /dev/null and b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi/storageFourway.png differ
diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi/storageStraight.png b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi/storageStraight.png
new file mode 100644
index 00000000000..5806fd083c4
Binary files /dev/null and b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi/storageStraight.png differ
diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi/storageTjunction.png b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi/storageTjunction.png
new file mode 100644
index 00000000000..da30f800f37
Binary files /dev/null and b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi/storageTjunction.png differ
diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/bottler.png b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/bottler.png
new file mode 100644
index 00000000000..f902a47a5a2
Binary files /dev/null and b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/bottler.png differ
diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/disposal.png b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/disposal.png
new file mode 100644
index 00000000000..12e5ecf8d98
Binary files /dev/null and b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/disposal.png differ
diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/disposal_working.png b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/disposal_working.png
new file mode 100644
index 00000000000..994262ec863
Binary files /dev/null and b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/disposal_working.png differ
diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/ductConnector.png b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/ductConnector.png
new file mode 100644
index 00000000000..f80ebbb016f
Binary files /dev/null and b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/ductConnector.png differ
diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/ductConnector_connected.png b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/ductConnector_connected.png
new file mode 100644
index 00000000000..b02d4a01e14
Binary files /dev/null and b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/ductConnector_connected.png differ
diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/filter.png b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/filter.png
new file mode 100644
index 00000000000..4daac73a063
Binary files /dev/null and b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/filter.png differ
diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/filterF.png b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/filterF.png
new file mode 100644
index 00000000000..d00df89c66a
Binary files /dev/null and b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/filterF.png differ
diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/meta.json b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/meta.json
new file mode 100644
index 00000000000..4eb9bc8467f
--- /dev/null
+++ b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/meta.json
@@ -0,0 +1,114 @@
+{
+    "version": 1,
+    "license": "CC-BY-SA-3.0",
+    "copyright": "TGStation",
+    "size": {
+        "x": 32,
+        "y": 32
+    },
+    "states": [
+        {
+            "name": "bottler",
+            "directions": 4,
+            "copyright": "TGStation"
+        },
+        {
+            "name": "disposal",
+            "copyright": "TGStation"
+        },
+        {
+            "name": "disposal_working",
+            "delays": [
+                [
+                    0.1,
+                    0.1,
+                    0.1,
+                    0.1,
+                    0.1
+                ]
+            ],
+            "copyright": "TGStation"
+        },
+        {
+            "name": "ductConnector",
+            "directions": 4,
+            "copyright": "TGStation"
+        },
+        {
+            "name": "ductConnector_connected",
+            "directions": 4,
+            "copyright": "TGStation"
+        },
+        {
+            "name": "filter",
+            "directions": 4,
+            "copyright": "TGStation"
+        },
+        {
+            "name": "filterF",
+            "directions": 4,
+            "copyright": "TGStation"
+        },
+        {
+            "name": "pill_press",
+            "directions": 4,
+            "delays": [
+                [ 0.1, 0.1, 0.1 ],
+                [ 0.1, 0.1, 0.1 ],
+                [ 0.1, 0.1, 0.1 ],
+                [ 0.1, 0.1, 0.1 ]
+            ],
+            "copyright": "TGStation"
+        },
+        {
+            "name": "pill_press_off",
+            "directions": 4,
+            "copyright": "TGStation"
+        },
+        {
+            "name": "pipe_input",
+            "directions": 4,
+            "copyright": "TGStation"
+        },
+        {
+            "name": "pipe_output",
+            "directions": 4,
+            "copyright": "TGStation"
+        },
+        {
+            "name": "reaction_chamber",
+            "directions": 4,
+            "copyright": "TGStation"
+        },
+        {
+            "name": "reaction_chamber_on",
+            "directions": 4,
+            "delays": [ [ 0.2, 0.2, 0.2, 0.2 ], [ 0.2, 0.2, 0.2, 0.2 ], [ 0.2, 0.2, 0.2, 0.2 ], [ 0.2, 0.2, 0.2, 0.2 ] ],
+            "copyright": "TGStation"
+        },
+        {
+            "name": "synthesizer",
+            "directions": 4,
+            "copyright": "TGStation"
+        },
+        {
+            "name": "synthesizer_inactive",
+            "directions": 4,
+            "copyright": "TGStation"
+        },
+        {
+            "name": "synthesizer_overlay",
+            "directions": 4,
+            "copyright": "TGStation"
+        },
+        {
+            "name": "tank",
+            "directions": 4,
+            "copyright": "TGStation"
+        },
+        {
+            "name": "tap_output",
+            "copyright": "TGStation"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/pill_press.png b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/pill_press.png
new file mode 100644
index 00000000000..b00439fb855
Binary files /dev/null and b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/pill_press.png differ
diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/pill_press_off.png b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/pill_press_off.png
new file mode 100644
index 00000000000..b462921a6cc
Binary files /dev/null and b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/pill_press_off.png differ
diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/pipe_input.png b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/pipe_input.png
new file mode 100644
index 00000000000..295b90ebf07
Binary files /dev/null and b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/pipe_input.png differ
diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/pipe_output.png b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/pipe_output.png
new file mode 100644
index 00000000000..7b059277459
Binary files /dev/null and b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/pipe_output.png differ
diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/reaction_chamber.png b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/reaction_chamber.png
new file mode 100644
index 00000000000..df30be70209
Binary files /dev/null and b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/reaction_chamber.png differ
diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/reaction_chamber_on.png b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/reaction_chamber_on.png
new file mode 100644
index 00000000000..794e9d7e64c
Binary files /dev/null and b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/reaction_chamber_on.png differ
diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/synthesizer.png b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/synthesizer.png
new file mode 100644
index 00000000000..e89dfeac9db
Binary files /dev/null and b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/synthesizer.png differ
diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/synthesizer_inactive.png b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/synthesizer_inactive.png
new file mode 100644
index 00000000000..0a740e719d6
Binary files /dev/null and b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/synthesizer_inactive.png differ
diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/synthesizer_overlay.png b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/synthesizer_overlay.png
new file mode 100644
index 00000000000..9863f76829c
Binary files /dev/null and b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/synthesizer_overlay.png differ
diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/tank.png b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/tank.png
new file mode 100644
index 00000000000..7b500de2dc6
Binary files /dev/null and b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/tank.png differ
diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/tap_output.png b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/tap_output.png
new file mode 100644
index 00000000000..0a0702ba1d3
Binary files /dev/null and b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/tap_output.png differ