MemoryWriteStream: enforce single-flush semantics

PowerKit.Tests/MemoryWriteStreamTests.cs

@@ -1,3 +1,4 @@
+using System;
 using System.IO;
 using FluentAssertions;
 using PowerKit.Tests.Utils;
@@ -29,4 +30,32 @@ public void MemoryWriteStream_Test()
         seekable.CanSeek.Should().BeTrue();
         destination.ToArray().Should().Equal(data);
     }
+
+    [Fact]
+    public void MemoryWriteStream_FlushTwice_Throws()
+    {
+        // Arrange
+        using var destination = new MemoryStream();
+        using var seekable = new MemoryWriteStream(destination);
+
+        seekable.Write([1, 2, 3]);
+        seekable.Flush();
+
+        // Act & Assert
+        seekable.Invoking(s => s.Flush()).Should().Throw<InvalidOperationException>();
+    }
+
+    [Fact]
+    public void MemoryWriteStream_FlushThenDispose_DoesNotThrow()
+    {
+        // Arrange
+        using var destination = new MemoryStream();
+        var seekable = new MemoryWriteStream(destination);
+
+        seekable.Write([1, 2, 3]);
+        seekable.Flush();
+
+        // Act & Assert
+        seekable.Invoking(s => s.Dispose()).Should().NotThrow();
+    }
 }

PowerKit/MemoryWriteStream.cs

@@ -15,6 +15,8 @@ namespace PowerKit;
 public class MemoryWriteStream(Stream source) : Stream
 {
     private readonly MemoryStream _buffer = new();
+    private bool _flushed;
+    private bool _disposing;
 
     /// <inheritdoc />
     public override bool CanRead => false;
@@ -38,9 +40,31 @@ public override long Position
     /// <inheritdoc />
     public override void Flush()
     {
+        if (_flushed)
+        {
+            if (_disposing)
+                return;
+
+            throw new InvalidOperationException(
+                $"{nameof(MemoryWriteStream)} has already been flushed."
+            );
+        }
+
         _buffer.Position = 0;
         _buffer.CopyTo(source);
         source.Flush();
+        _flushed = true;
+    }
+
+    /// <inheritdoc />
+    protected override void Dispose(bool disposing)
+    {
+        // Set and clear _disposing so that the implicit Flush() called by base.Dispose()
+        // is treated as non-manual. The flag must be reset afterwards so that any erroneous
+        // Flush() calls made after disposal still throw rather than silently returning.
+        _disposing = true;
+        base.Dispose(disposing);
+        _disposing = false;
     }
 
     /// <inheritdoc />