gg.easy.airship 0.1.2136 → 0.1.2138

package/Runtime/Code/Zstd/Zstd.cs

@@ -1,6 +1,5 @@
 using System;
-using System.Runtime.InteropServices;
-
+using System.Buffers;
 using static Code.Zstd.ZstdNative;
 
 namespace Code.Zstd {
@@ -33,32 +32,85 @@ namespace Code.Zstd {
 		/// and <c>Zstd.MaxCompressionLevel</c>. Most use-cases should use <c>Zstd.DefaultCompressionLevel</c>.
 		/// </summary>
 		public byte[] Compress(byte[] data, int compressionLevel) {
-			return CompressData(data, compressionLevel, _ctx);
+			return Compress(new ReadOnlySpan<byte>(data), compressionLevel);
+		}
+		
+		/// <summary>
+		/// Compress the data. The compression level can be between <c>Zstd.MinCompressionLevel</c>
+		/// and <c>Zstd.MaxCompressionLevel</c>. Most use-cases should use <c>Zstd.DefaultCompressionLevel</c>.
+		/// </summary>
+		public byte[] Compress(byte[] data, int start, int length, int compressionLevel) {
+			return Compress(new ReadOnlySpan<byte>(data, start, length), compressionLevel);
 		}
 		
 		/// <summary>
 		/// Compress the data using the default compression level.
 		/// </summary>
 		public byte[] Compress(byte[] data) {
-			return CompressData(data, DefaultCompressionLevel, _ctx);
+			return Compress(new ReadOnlySpan<byte>(data));
+		}
+		
+		/// <summary>
+		/// Compress the data using the default compression level.
+		/// </summary>
+		public byte[] Compress(byte[] data, int start, int length) {
+			return Compress(new ReadOnlySpan<byte>(data, start, length));
+		}
+
+		/// <summary>
+		/// Compress the data using the default compression level.
+		/// </summary>
+		public byte[] Compress(ReadOnlySpan<byte> data) {
+			return Compress(data, DefaultCompressionLevel);
+		}
+
+		/// <summary>
+		/// Compress the data. The compression level can be between <c>Zstd.MinCompressionLevel</c>
+		/// and <c>Zstd.MaxCompressionLevel</c>. Most use-cases should use <c>Zstd.DefaultCompressionLevel</c>.
+		/// </summary>
+		public byte[] Compress(ReadOnlySpan<byte> data, int compressionLevel) {
+			return CompressData(data, compressionLevel, _ctx);
 		}
 		
 		/// <summary>
 		/// Decompress the data.
 		/// </summary>
 		public byte[] Decompress(byte[] data) {
+			return Decompress(new ReadOnlySpan<byte>(data));
+		}
+		
+		/// <summary>
+		/// Decompress the data.
+		/// </summary>
+		public byte[] Decompress(byte[] data, int start, int length) {
+			return Decompress(new ReadOnlySpan<byte>(data, start, length));
+		}
+		
+		/// <summary>
+		/// Decompress the data.
+		/// </summary>
+		public byte[] Decompress(ReadOnlySpan<byte> data) {
 			return DecompressData(data, _ctx);
 		}
 
 		public void Dispose() {
+			Dispose(true);
+			GC.SuppressFinalize(this);
+		}
+
+		protected virtual void Dispose(bool disposing) {
 			_ctx.Dispose();
 		}
 
+		~Zstd() {
+			Dispose(false);
+		}
+
 		/// <summary>
 		/// Compress the bytes. The compression level can be between <c>Zstd.MinCompressionLevel</c>
 		/// and <c>Zstd.MaxCompressionLevel</c>. Most use-cases should use <c>Zstd.DefaultCompressionLevel</c>.
 		/// </summary>
-		public static byte[] CompressData(byte[] data, int compressionLevel, ZstdContext ctx = null) {
+		public static byte[] CompressData(ReadOnlySpan<byte> data, int compressionLevel, ZstdContext ctx = null) {
 			var bound = ZSTD_compressBound((ulong)data.Length);
 			if (ZSTD_isError(bound)) {
 				throw new ZstdException(bound);
@@ -72,33 +124,34 @@ namespace Code.Zstd {
 		/// <summary>
 		/// Decompress the bytes.
 		/// </summary>
-		public static byte[] DecompressData(byte[] data, ZstdContext ctx = null) {
-			var dataHandle = GCHandle.Alloc(data, GCHandleType.Pinned);
-			var rSize = ZSTD_getFrameContentSize(dataHandle.AddrOfPinnedObject(), (ulong)data.Length);
+		public static unsafe byte[] DecompressData(ReadOnlySpan<byte> data, ZstdContext ctx = null) {
+			ulong rSize;
+			fixed (byte* src = data) {
+				rSize = ZSTD_getFrameContentSize(new IntPtr(src), (ulong)data.Length);
+			}
 			if (ZSTD_isError(rSize)) {
-				dataHandle.Free();
 				throw new ZstdException(rSize);
 			}
 			byte[] decompressedData;
 			if (rSize <= MaxStackSize) {
-				decompressedData = DecompressWithStack(data, dataHandle, rSize, ctx);
+				decompressedData = DecompressWithStack(data, rSize, ctx);
 			} else {
-				decompressedData = DecompressWithHeap(data, dataHandle, rSize, ctx);
+				decompressedData = DecompressWithHeap(data, rSize, ctx);
 			}
-			dataHandle.Free();
 			return decompressedData;
 		}
 
-		private static unsafe byte[] DecompressWithStack(byte[] data, GCHandle dataHandle, ulong rSize, ZstdContext ctx) {
+		private static unsafe byte[] DecompressWithStack(ReadOnlySpan<byte> data, ulong rSize, ZstdContext ctx) {
 			var decompressedData = stackalloc byte[(int)rSize];
 			ulong decompressedSize;
-			if (ctx != null) {
-				decompressedSize = ZSTD_decompressDCtx(ctx.Dctx, new IntPtr(decompressedData), rSize, dataHandle.AddrOfPinnedObject(), (ulong)data.Length);
-			} else {
-				decompressedSize = ZSTD_decompress(new IntPtr(decompressedData), rSize, dataHandle.AddrOfPinnedObject(), (ulong)data.Length);
+			fixed (byte* src = data) {
+				if (ctx != null) {
+					decompressedSize = ZSTD_decompressDCtx(ctx.Dctx, new IntPtr(decompressedData), rSize, new IntPtr(src), (ulong)data.Length);
+				} else {
+					decompressedSize = ZSTD_decompress(new IntPtr(decompressedData), rSize, new IntPtr(src), (ulong)data.Length);
+				}
 			}
 			if (ZSTD_isError(decompressedSize)) {
-				dataHandle.Free();
 				throw new ZstdException(decompressedSize);
 			}
 			var decompressedBuffer = new byte[decompressedSize];
@@ -108,35 +161,36 @@ namespace Code.Zstd {
 			return decompressedBuffer;
 		}
 
-		private static byte[] DecompressWithHeap(byte[] data, GCHandle dataHandle, ulong rSize, ZstdContext ctx) {
+		private static unsafe byte[] DecompressWithHeap(ReadOnlySpan<byte> data, ulong rSize, ZstdContext ctx) {
 			var allocDst = ctx == null || rSize > (ulong)ctx.ScratchBuffer.Length;
 			var decompressedData = allocDst ? new byte[rSize] : ctx.ScratchBuffer;
-			var dstHandle = GCHandle.Alloc(decompressedData, GCHandleType.Pinned);
 			ulong decompressedSize;
-			if (ctx != null) {
-				decompressedSize = ZSTD_decompressDCtx(ctx.Dctx, dstHandle.AddrOfPinnedObject(), rSize, dataHandle.AddrOfPinnedObject(), (ulong)data.Length);
-			} else {
-				decompressedSize = ZSTD_decompress(dstHandle.AddrOfPinnedObject(), rSize, dataHandle.AddrOfPinnedObject(), (ulong)data.Length);
+			fixed (byte* src = data) {
+				fixed (byte* dst = decompressedData) {
+					if (ctx != null) {
+						decompressedSize = ZSTD_decompressDCtx(ctx.Dctx, new IntPtr(dst), rSize, new IntPtr(src), (ulong)data.Length);
+					} else {
+						decompressedSize = ZSTD_decompress(new IntPtr(dst), rSize, new IntPtr(src), (ulong)data.Length);
+					}
+				}
 			}
-			dstHandle.Free();
 			if (ZSTD_isError(decompressedSize)) {
-				dataHandle.Free();
 				throw new ZstdException(decompressedSize);
 			}
 			Array.Resize(ref decompressedData, (int)decompressedSize);
 			return decompressedData;
 		}
 
-		private static unsafe byte[] CompressWithStack(byte[] data, ulong bound, int compressionLevel, ZstdContext ctx) {
+		private static unsafe byte[] CompressWithStack(ReadOnlySpan<byte> data, ulong bound, int compressionLevel, ZstdContext ctx) {
 			var dst = stackalloc byte[(int)bound];
-			var srcHandle = GCHandle.Alloc(data, GCHandleType.Pinned);
 			ulong compressedSize;
-			if (ctx != null) {
-				compressedSize = ZSTD_compressCCtx(ctx.Cctx, new IntPtr(dst), bound, srcHandle.AddrOfPinnedObject(), (ulong)data.Length, compressionLevel);
-			} else {
-				compressedSize = ZSTD_compress(new IntPtr(dst), bound, srcHandle.AddrOfPinnedObject(), (ulong)data.Length, compressionLevel);
+			fixed (byte* src = data) {
+				if (ctx != null) {
+					compressedSize = ZSTD_compressCCtx(ctx.Cctx, new IntPtr(dst), bound, new IntPtr(src), (ulong)data.Length, compressionLevel);
+				} else {
+					compressedSize = ZSTD_compress(new IntPtr(dst), bound, new IntPtr(src), (ulong)data.Length, compressionLevel);
+				}
 			}
-			srcHandle.Free();
 			if (ZSTD_isError(compressedSize)) {
 				throw new ZstdException(compressedSize);
 			}
@@ -147,40 +201,59 @@ namespace Code.Zstd {
 			return compressedBuffer;
 		}
 
-		private static byte[] CompressWithHeap(byte[] data, ulong bound, int compressionLevel, ZstdContext ctx) {
+		private static unsafe byte[] CompressWithHeap(ReadOnlySpan<byte> data, ulong bound, int compressionLevel, ZstdContext ctx) {
 			var allocDst = ctx == null || bound > (ulong)ctx.ScratchBuffer.Length;
-			var dst = allocDst ? new byte[bound] : ctx.ScratchBuffer;
-			var dstHandle = GCHandle.Alloc(dst, GCHandleType.Pinned);
-			var srcHandle = GCHandle.Alloc(data, GCHandleType.Pinned);
+			var dstBuf = allocDst ? new byte[bound] : ctx.ScratchBuffer;
 			ulong compressedSize;
-			if (ctx != null) {
-				compressedSize = ZSTD_compressCCtx(ctx.Cctx, dstHandle.AddrOfPinnedObject(), bound, srcHandle.AddrOfPinnedObject(), (ulong)data.Length, compressionLevel);
-			} else {
-				compressedSize = ZSTD_compress(dstHandle.AddrOfPinnedObject(), bound, srcHandle.AddrOfPinnedObject(), (ulong)data.Length, compressionLevel);
+			fixed (byte* src = data) {
+				fixed (byte* dst = dstBuf) {
+					if (ctx != null) {
+						compressedSize = ZSTD_compressCCtx(ctx.Cctx, new IntPtr(dst), bound, new IntPtr(src), (ulong)data.Length, compressionLevel);
+					}
+					else {
+						compressedSize = ZSTD_compress(new IntPtr(dst), bound, new IntPtr(src), (ulong)data.Length, compressionLevel);
+					}
+				}
 			}
-			dstHandle.Free();
-			srcHandle.Free();
 			if (ZSTD_isError(compressedSize)) {
 				throw new ZstdException(compressedSize);
 			}
-			Array.Resize(ref dst, (int)compressedSize);
-			return dst;
+			Array.Resize(ref dstBuf, (int)compressedSize);
+			return dstBuf;
 		}
 	}
 
-	public class ZstdContext : IDisposable {
+	public sealed class ZstdContext : IDisposable {
 		internal readonly byte[] ScratchBuffer;
 		
 		internal readonly IntPtr Cctx;
 		internal readonly IntPtr Dctx;
+
+		private bool _disposed;
 		
 		public ZstdContext(ulong scratchBufferSize) {
-			ScratchBuffer = new byte[scratchBufferSize];
+			ScratchBuffer = ArrayPool<byte>.Shared.Rent((int)scratchBufferSize);
 			Cctx = ZSTD_createCCtx();
 			Dctx = ZSTD_createDCtx();
 		}
 
+		~ZstdContext() {
+			Dispose(false);
+		}
+
 		public void Dispose() {
+			Dispose(true);
+			GC.SuppressFinalize(this);
+		}
+
+		private void Dispose(bool disposing) {
+			if (_disposed) return;
+			_disposed = true;
+			
+			if (disposing) {
+				ArrayPool<byte>.Shared.Return(ScratchBuffer);
+			}
+			
 			ZSTD_freeCCtx(Cctx);
 			ZSTD_freeDCtx(Dctx);
 		}
@@ -189,4 +262,9 @@ namespace Code.Zstd {
 	public class ZstdException : Exception {
 		public ZstdException(ulong code) : base(ZSTD_getErrorName(code)) { }
 	}
+
+	public class ZstdStreamException : Exception {
+		public ZstdStreamException(string message) : base(message) { }
+		public ZstdStreamException(ulong code) : this(ZSTD_getErrorName(code)) { }
+	}
 }

package/Runtime/Code/Zstd/ZstdCompressStream.cs

@@ -0,0 +1,147 @@
+using System;
+using System.Buffers;
+using System.IO;
+using System.Runtime.InteropServices;
+using static Code.Zstd.ZstdNative;
+
+namespace Code.Zstd {
+	/// <summary>
+	/// Provides methods for compressing streams using the zstd algorithm.
+	/// </summary>
+	public sealed class ZstdCompressStream : Stream {
+		public override bool CanRead => false;
+		public override bool CanSeek => false;
+		public override bool CanWrite => true;
+		public override long Length => _compressedStream.Length;
+		public override long Position { get; set; }
+
+		private readonly Stream _compressedStream;
+		private readonly bool _leaveOpen;
+
+		private IntPtr _cctx;
+		private GCHandle _outHandle;
+		private readonly byte[] _bufOut;
+		private readonly ulong _bufOutSize;
+
+		private bool _disposed;
+
+		/// <summary>
+		/// Constructs a new ZstdCompressionStream.
+		/// </summary>
+		/// <param name="compressedStream">The stream to which compressed data is written.</param>
+		/// <param name="leaveOpen">Optionally leave the <c>compressedStream</c> open after closing (defaults to <c>false</c>).</param>
+		public ZstdCompressStream(Stream compressedStream, bool leaveOpen = false) : this(compressedStream, Zstd.DefaultCompressionLevel, leaveOpen) { }
+
+		/// <summary>
+		/// Constructs a new ZstdCompressionStream.
+		/// </summary>
+		/// <param name="compressedStream">The stream to which compressed data is written.</param>
+		/// <param name="compressionLevel">The zstd compression level. This should be in the range of <c>Zstd.MinCompressionLevel</c> and <c>Zstd.MaxCompressionLevel</c>. Most use-cases should use <c>Zstd.DefaultCompressionLevel</c>.</param>
+		/// <param name="leaveOpen">Optionally leave the <c>compressedStream</c> open after closing (defaults to <c>false</c>).</param>
+		public ZstdCompressStream(Stream compressedStream, int compressionLevel, bool leaveOpen = false) {
+			_compressedStream = compressedStream;
+			_leaveOpen = leaveOpen;
+
+			_cctx = ZSTD_createCCtx();
+
+			_bufOutSize = ZSTD_CStreamOutSize();
+			_bufOut = ArrayPool<byte>.Shared.Rent((int)_bufOutSize);
+			
+			_outHandle = GCHandle.Alloc(_bufOut, GCHandleType.Pinned);
+			
+			ZSTD_CCtx_setParameter(_cctx, ZSTD_cParameter.ZSTD_c_compressionLevel, compressionLevel);
+		}
+		
+		public override void Flush() {
+			var finished = false;
+			do {
+				var output = new ZSTD_outBuffer {
+					dst = _outHandle.AddrOfPinnedObject(),
+					size = _bufOutSize,
+					pos = 0,
+				};
+				var remaining = ZSTD_flushStream(_cctx, ref output);
+				if (ZSTD_isError(remaining)) {
+					throw new ZstdStreamException(remaining);
+				}
+				_compressedStream.Write(_bufOut, 0, (int)output.pos);
+				finished = remaining == 0;
+			} while (!finished);
+		}
+
+		public override int Read(byte[] buffer, int offset, int count) {
+			throw new NotSupportedException();
+		}
+
+		public override long Seek(long offset, SeekOrigin origin) {
+			throw new NotSupportedException();
+		}
+
+		public override void SetLength(long value) {
+			throw new NotSupportedException();
+		}
+
+		public override void Write(byte[] buffer, int offset, int count) {
+			WriteCore(new ReadOnlySpan<byte>(buffer, offset, count));
+		}
+
+		public override void Write(ReadOnlySpan<byte> buffer) {
+			WriteCore(buffer);
+		}
+
+		private unsafe void WriteCore(ReadOnlySpan<byte> buffer) {
+			fixed (byte* bufferPtr = &MemoryMarshal.GetReference(buffer)) {
+				var input = new ZSTD_inBuffer {
+					src = (IntPtr)bufferPtr,
+					size = (ulong)buffer.Length,
+					pos = 0,
+				};
+
+				do {
+					var output = new ZSTD_outBuffer {
+						dst = _outHandle.AddrOfPinnedObject(),
+						size = _bufOutSize,
+						pos = 0,
+					};
+					var ret = ZSTD_compressStream(_cctx, ref output, ref input);
+					if (ZSTD_isError(ret)) {
+						throw new ZstdStreamException(ret);
+					}
+					_compressedStream.Write(_bufOut, 0, (int)output.pos);
+				} while (input.pos != input.size);
+			}
+		}
+
+		protected override void Dispose(bool disposing) {
+			base.Dispose(disposing);
+			if (disposing && !_disposed) {
+				var finished = false;
+				do {
+					var output = new ZSTD_outBuffer {
+						dst = _outHandle.AddrOfPinnedObject(),
+						size = _bufOutSize,
+						pos = 0,
+					};
+					var remaining = ZSTD_endStream(_cctx, ref output);
+					if (ZSTD_isError(remaining)) {
+						throw new ZstdStreamException(remaining);
+					}
+					_compressedStream.Write(_bufOut, 0, (int)output.pos);
+					finished = remaining == 0;
+				} while (!finished);
+				
+				_outHandle.Free();
+				ArrayPool<byte>.Shared.Return(_bufOut);
+			
+				if (!_leaveOpen) {
+					_compressedStream.Close();
+				}
+			}
+
+			ZSTD_freeCCtx(_cctx);
+			_cctx = IntPtr.Zero;
+			
+			_disposed = true;
+		}
+	}
+}

package/Runtime/Code/Zstd/ZstdCompressStream.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 104c04ecb4754bbbb6d840b586afa217
+timeCreated: 1748324334

package/Runtime/Code/Zstd/ZstdDecompressStream.cs

@@ -0,0 +1,196 @@
+using System;
+using System.Buffers;
+using System.IO;
+using System.Runtime.InteropServices;
+using static Code.Zstd.ZstdNative;
+
+namespace Code.Zstd {
+	/// <summary>
+	/// Provides methods for decompressing streams using the zstd algorithm.
+	/// </summary>
+	public sealed class ZstdDecompressStream : Stream {
+		public override bool CanRead => true;
+		public override bool CanSeek => false;
+		public override bool CanWrite => false;
+		public override long Length => _compressedStream.Length;
+		public override long Position { get; set; }
+
+		private readonly Stream _compressedStream;
+		private readonly bool _leaveOpen;
+
+		private IntPtr _dctx;
+		private GCHandle _outHandle;
+		private GCHandle _inHandle;
+		private readonly byte[] _bufOut;
+		private readonly byte[] _bufIn;
+		private readonly ulong _bufOutSize;
+		private readonly ulong _bufInSize;
+
+		private readonly MemoryStream _bufOutStream;
+
+		private int _currentBufOutOffset;
+		private int _currentBufIn;
+		
+		private bool _disposed;
+
+		/// <summary>
+		/// Constructs a new ZstdDecompressionStream.
+		/// </summary>
+		/// <param name="compressedStream">The source stream from which compressed data is decompressed.</param>
+		/// <param name="leaveOpen">Optionally leave the <c>compressedStream</c> open after closing (defaults to <c>false</c>).</param>
+		public ZstdDecompressStream(Stream compressedStream, bool leaveOpen = false) {
+			_compressedStream = compressedStream;
+			_leaveOpen = leaveOpen;
+
+			_dctx = ZSTD_createDCtx();
+			
+			_bufOutSize = ZSTD_DStreamOutSize();
+			_bufInSize = ZSTD_DStreamInSize();
+			
+			_bufOut = ArrayPool<byte>.Shared.Rent((int)_bufOutSize);
+			_bufIn = ArrayPool<byte>.Shared.Rent((int)_bufInSize);
+			
+			_outHandle = GCHandle.Alloc(_bufOut, GCHandleType.Pinned);
+			_inHandle = GCHandle.Alloc(_bufIn, GCHandleType.Pinned);
+
+			_bufOutStream = new MemoryStream((int)ZSTD_DStreamOutSize());
+		}
+		
+		public override void Flush() {
+			throw new NotSupportedException();
+		}
+
+		public override int Read(byte[] buffer, int offset, int count) {
+			return ReadCore(new Span<byte>(buffer, offset, count));
+		}
+
+		public override int Read(Span<byte> buffer) {
+			return ReadCore(buffer);
+		}
+
+		private int ReadCore(Span<byte> buffer) {
+			var read = 0;
+			var lastRet = 0ul;
+			var streamEmpty = false;
+			var bufferOffset = 0;
+
+			if (buffer.IsEmpty) {
+				throw new ZstdStreamException("Empty buffer");
+			}
+
+			while (true) {
+				if (_bufOutStream.Length > 0) {
+					var len = Math.Min(buffer.Length, (int)(_bufOutStream.Length - _currentBufOutOffset));
+					_bufOutStream.Seek(_currentBufOutOffset, SeekOrigin.Begin);
+					var bufOutRead = _bufOutStream.Read(buffer.Slice(bufferOffset, len));
+					if (bufOutRead != len) {
+						throw new ZstdStreamException("Failed to read full amount into buffer");
+					}
+					_currentBufOutOffset += len;
+					bufferOffset += len;
+					read += len;
+					
+					if (_currentBufOutOffset == _bufOutStream.Length) {
+						_currentBufOutOffset = 0;
+						_bufOutStream.Seek(0, SeekOrigin.Begin);
+						_bufOutStream.SetLength(0);
+					}
+
+					if (len == buffer.Length) {
+						break;
+					}
+				}
+
+				if (_bufOutStream.Length == 0) {
+					if (_currentBufIn == 0) {
+						var bytesFromStream = ReadInCompressedChunkFromStream();
+						streamEmpty = bytesFromStream == 0;
+					}
+
+					if (!streamEmpty) {
+						lastRet = Decompress();
+					}
+				}
+
+				if (streamEmpty && _bufOutStream.Length == 0) {
+					break;
+				}
+			}
+
+			if (streamEmpty && _bufOutStream.Length == 0 && lastRet != 0) {
+				throw new ZstdStreamException($"EOF before end of stream: {lastRet}");
+			}
+
+			return read;
+		}
+
+		private ulong Decompress() {
+			var lastRet = 0ul;
+			
+			var input = new ZSTD_inBuffer {
+				src = _inHandle.AddrOfPinnedObject(),
+				size = (ulong)_currentBufIn,
+				pos = 0,
+			};
+			
+			while (input.pos < input.size) {
+				var output = new ZSTD_outBuffer {
+					dst = _outHandle.AddrOfPinnedObject(),
+					size = _bufOutSize,
+					pos = 0,
+				};
+				
+				lastRet = ZSTD_decompressStream(_dctx, ref output, ref input);
+				if (ZSTD_isError(lastRet)) {
+					throw new ZstdStreamException(lastRet);
+				}
+
+				_bufOutStream.Write(_bufOut, 0, (int)output.pos);
+			}
+			
+			_currentBufIn = 0;
+
+			return lastRet;
+		}
+
+		private int ReadInCompressedChunkFromStream() {
+			var streamRead = 0;
+			if (_currentBufIn < (int)_bufInSize) {
+				streamRead = _compressedStream.Read(_bufIn, _currentBufIn, (int)_bufInSize - _currentBufIn);
+				_currentBufIn += streamRead;
+			}
+			return streamRead;
+		}
+
+		public override long Seek(long offset, SeekOrigin origin) {
+			throw new NotSupportedException();
+		}
+
+		public override void SetLength(long value) {
+			throw new NotSupportedException();
+		}
+
+		public override void Write(byte[] buffer, int offset, int count) {
+			throw new NotSupportedException();
+		}
+
+		protected override void Dispose(bool disposing) {
+			base.Dispose(disposing);
+			if (disposing && !_disposed) {
+				_outHandle.Free();
+				_inHandle.Free();
+				ArrayPool<byte>.Shared.Return(_bufOut);
+				ArrayPool<byte>.Shared.Return(_bufIn);
+				if (!_leaveOpen) {
+					_compressedStream.Close();
+				}
+				_bufOutStream.Dispose();
+			}
+
+			ZSTD_freeDCtx(_dctx);
+			_dctx = IntPtr.Zero;
+			
+			_disposed = true;
+		}
+	}
+}

package/Runtime/Code/Zstd/ZstdDecompressStream.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 17b1cf21ff70448ba38b34ea9f3428c1
+timeCreated: 1748328585

package/Runtime/Code/Zstd/ZstdNative.cs

@@ -327,7 +327,7 @@ namespace Code.Zstd {
 #else
 		[DllImport("LuauPlugin")]
 #endif
-		internal static extern ulong ZSTD_compressStream2(IntPtr cctx, ZSTD_outBuffer output, ZSTD_inBuffer input, ZSTD_EndDirective endOp);
+		internal static extern ulong ZSTD_compressStream2(IntPtr cctx, ref ZSTD_outBuffer output, ref ZSTD_inBuffer input, ZSTD_EndDirective endOp);
 		
 #if UNITY_IPHONE
 		[DllImport("__Internal")]
@@ -355,21 +355,21 @@ namespace Code.Zstd {
 #else
 		[DllImport("LuauPlugin")]
 #endif
-		internal static extern ulong ZSTD_compressStream(IntPtr zcs, ZSTD_outBuffer output, ZSTD_inBuffer input);
+		internal static extern ulong ZSTD_compressStream(IntPtr zcs, ref ZSTD_outBuffer output, ref ZSTD_inBuffer input);
 		
 #if UNITY_IPHONE
 		[DllImport("__Internal")]
 #else
 		[DllImport("LuauPlugin")]
 #endif
-		internal static extern ulong ZSTD_flushStream(IntPtr zcs, ZSTD_outBuffer output);
+		internal static extern ulong ZSTD_flushStream(IntPtr zcs, ref ZSTD_outBuffer output);
 		
 #if UNITY_IPHONE
 		[DllImport("__Internal")]
 #else
 		[DllImport("LuauPlugin")]
 #endif
-		internal static extern ulong ZSTD_endStream(IntPtr zcs, ZSTD_outBuffer output);
+		internal static extern ulong ZSTD_endStream(IntPtr zcs, ref ZSTD_outBuffer output);
 		
 #if UNITY_IPHONE
 		[DllImport("__Internal")]
@@ -397,7 +397,7 @@ namespace Code.Zstd {
 #else
 		[DllImport("LuauPlugin")]
 #endif
-		internal static extern ulong ZSTD_decompressStream(IntPtr zds, ZSTD_outBuffer output, ZSTD_inBuffer input);
+		internal static extern ulong ZSTD_decompressStream(IntPtr zds, ref ZSTD_outBuffer output, ref ZSTD_inBuffer input);
 		
 #if UNITY_IPHONE
 		[DllImport("__Internal")]

package/Runtime/Plugins/Mac/LuauPlugin.bundle/Contents/Info.plist

@@ -3,7 +3,7 @@
 <plist version="1.0">
 <dict>
 	<key>BuildMachineOSBuild</key>
-	<string>23H527</string>
+	<string>23H626</string>
 	<key>CFBundleDevelopmentRegion</key>
 	<string>en</string>
 	<key>CFBundleExecutable</key>