gg.easy.airship 0.1.2136 → 0.1.2137

package/Editor/Artifacts/AirshipLocalArtifactDatabase.cs

@@ -150,7 +150,11 @@ namespace Airship.Editor {
         /// Will try to get the script asset data associated with the specified script (if applicable)
         /// </summary>
         internal bool TryGetScriptAssetData(AirshipScript script, out ComponentScriptAssetData assetData) {
-            var item = scripts.FirstOrDefault(f => f.script == script.assetPath);
+            return TryGetScriptAssetDataFromPath(script.assetPath, out assetData);
+        }
+
+        internal bool TryGetScriptAssetDataFromPath(string path, out ComponentScriptAssetData assetData) {
+            var item = scripts.FirstOrDefault(f => f.script == path);
             if (item != null) {
                 assetData = item;
                 return true;

package/Editor/TypescriptServices/Compiler/TypescriptCompilationService.cs

@@ -225,18 +225,42 @@ using Object = UnityEngine.Object;
                     return;
                 }
 
+                var artifacts = AirshipLocalArtifactDatabase.instance;
+                var modifiedDatabase = false;
+                
                 try {
                     AssetDatabase.StartAssetEditing();
                     var compileFileList = CompiledFileQueue.ToArray();
+                    
                     foreach (var file in compileFileList) {
-                        // var asset = AssetDatabase.LoadAssetAtPath<AirshipScript>(file);
-                        AssetDatabase.ImportAsset(file, ImportAssetOptions.Default);
+                        var outFileHash = TypescriptProjectsService.Project.GetOutputFileHash(file);
+                        
+                        if (artifacts.TryGetScriptAssetDataFromPath(PosixPath.ToPosix(file), out var data)) {
+                            if (outFileHash != data.metadata.compiledHash) {
+                                AssetDatabase.ImportAsset(file, ImportAssetOptions.Default);
+                                data.metadata.compiledHash = outFileHash;
+                                modifiedDatabase = true;
+                            }
+                        }
+                        else {
+                            var scriptData = artifacts.GetOrCreateScriptAssetData(AssetDatabase.LoadAssetAtPath<AirshipScript>(file));
+                            scriptData.metadata = new TypescriptCompilerMetadata() {
+                                compiledHash = outFileHash
+                            };
+                            
+                            AssetDatabase.ImportAsset(file, ImportAssetOptions.Default);
+                            modifiedDatabase = true;
+                        }
                     }
+                    
                     AssetDatabase.Refresh();
                 } catch (Exception ex) {
-                    Debug.LogError("[Airship] Failed to reimport compiled files: " + ex);
+                    Debug.LogException(ex);
                 } finally {
                     AssetDatabase.StopAssetEditing();
+                    if (modifiedDatabase) {
+                        artifacts.Modify();
+                    }
                 }
                 
                 EditorApplication.update -= ReimportCompiledFiles;

package/Editor/TypescriptServices/TypescriptServices.cs

@@ -65,7 +65,7 @@ namespace Airship.Editor {
             return;
 #endif
             // On project load we'll force a full compile to try and get all the refs up to date
-            if (!SessionState.GetBool("TypescriptInitialBoot", false)) {
+            if (!SessionState.GetBool("TypescriptInitialBoot", false) && IsValidEditor) {
                 SessionState.SetBool("TypescriptInitialBoot", true);
                 TypescriptCompilationService.BuildTypescript(TypeScriptCompileFlags.FullClean | TypeScriptCompileFlags.Setup | TypeScriptCompileFlags.DisplayProgressBar);
             }

package/Runtime/Code/Luau/AirshipScript.cs

@@ -18,6 +18,8 @@ namespace Luau {
         /// The file hash at the compile time
         /// </summary>
         public string hash;
+
+        public string compiledHash;
         /// <summary>
         /// The timestamp when this was compiled
         /// </summary>

package/Runtime/Code/Network/Simulation/AirshipSimulationManager.cs

@@ -102,12 +102,10 @@ namespace Code.Network.Simulation
          */
         public event Action<int, double, double> OnLagCompensationCheck;
 
-        /**
-         * This action tells all watching components that they need to perform a tick.
-         * A Physics.Simulate() call will be made after PerformTick completes.
-         */
-        public event Action<double, bool> OnPerformTick;
-
+        /// <summary>
+        /// This action tells all watching components that they need to perform a tick.
+        /// A Physics.Simulate() call will be made after PerformTick completes.
+        /// </summary>
         public event Action<object, object> OnTick;
 
         /**
@@ -184,7 +182,6 @@ namespace Code.Network.Simulation
             if (resimBackTo != time) this.PerformResimulation(resimBackTo);
 
             // Perform the standard tick behavior
-            OnPerformTick?.Invoke(time, false);
             OnTick?.Invoke(time, false);
             // Debug.Log("Simulate call. Main Tick: " + NetworkTime.time);
             Physics.Simulate(Time.fixedDeltaTime);
@@ -310,13 +307,14 @@ namespace Code.Network.Simulation
             this.ScheduleResimulation((resim => resim(time)));
         }
 
-        /**
-         * Requests a simulation based on the provided time. Requesting a simulation will roll back the physics
-         * world to the snapshot just before or at the base time provided. Calling the returned tick function
-         * will advance the simulation and re-simulate the calls to OnPerformTick, Physics.Simulate(), and OnCaptureSnapshot
-         *
-         * This function is used internally to implement the scheduled resimulations.
-         */
+        /// <summary>
+        /// Requests a simulation based on the provided time. Requesting a simulation will roll back the physics
+        /// world to the snapshot just before or at the base time provided. Calling the returned tick function
+        /// will advance the simulation and re-simulate the calls to <see cref="OnTick"/>, Physics.Simulate,
+        /// and <see cref="OnCaptureSnapshot"/>
+        /// 
+        /// This function is used internally to implement the scheduled resimulations.
+        /// </summary>
         private void PerformResimulation(double baseTime)
         {
             Debug.Log($"T:{Time.unscaledTimeAsDouble} Resimulating from {baseTime}");
@@ -343,7 +341,7 @@ namespace Code.Network.Simulation
 
                 while (tickIndex < this.tickTimes.Count)
                 {
-                    OnPerformTick?.Invoke(this.tickTimes[tickIndex], true);
+                    OnTick?.Invoke(this.tickTimes[tickIndex], true);
                     // Debug.Log("Simulate call. Replay Tick: " + this.tickTimes[tickIndex]);
                     Physics.Simulate(Time.fixedDeltaTime);
                     OnCaptureSnapshot?.Invoke(this.tickTimes[tickIndex], true);

package/Runtime/Code/Network/StateSystem/AirshipNetworkedStateManager.cs

@@ -165,7 +165,7 @@ namespace Code.Network.StateSystem
         private void Awake()
         {
             AirshipSimulationManager.Instance.ActivateSimulationManager();
-            AirshipSimulationManager.Instance.OnPerformTick += this.OnPerformTick;
+            AirshipSimulationManager.Instance.OnTick += this.OnTick;
             AirshipSimulationManager.Instance.OnSetSnapshot += this.OnSetSnapshot;
             AirshipSimulationManager.Instance.OnCaptureSnapshot += this.OnCaptureSnapshot;
             AirshipSimulationManager.Instance.OnLagCompensationCheck += this.OnLagCompensationCheck;
@@ -195,7 +195,7 @@ namespace Code.Network.StateSystem
 
         public void OnDestroy()
         {
-            AirshipSimulationManager.Instance.OnPerformTick -= this.OnPerformTick;
+            AirshipSimulationManager.Instance.OnTick -= this.OnTick;
             AirshipSimulationManager.Instance.OnSetSnapshot -= this.OnSetSnapshot;
             AirshipSimulationManager.Instance.OnCaptureSnapshot -= this.OnCaptureSnapshot;
             AirshipSimulationManager.Instance.OnLagCompensationCheck -= this.OnLagCompensationCheck;
@@ -282,8 +282,9 @@ namespace Code.Network.StateSystem
 
         #region Top Level Event Functions
 
-        private void OnPerformTick(double time, bool replay)
-        {
+        private void OnTick(object timeObj, object replayObj) {
+            if (timeObj is not double time || replayObj is not bool replay) return;
+            
             // We are in shared mode
             if (isServer && isClient)
             {

package/Runtime/Code/VoxelWorld/Airship.VoxelWorld.asmdef

@@ -27,7 +27,8 @@
         "GUID:199bc21c5ec6a3e41b1d67e225a7bd04",
         "GUID:30817c1a0e6d646d99c048fc403f5979",
         "GUID:325984b52e4128546bc7558552f8b1d2",
-        "GUID:72872094b21c16e48b631b2224833d49"
+        "GUID:72872094b21c16e48b631b2224833d49",
+        "GUID:befe48b9a36afc04ea625c93daad910e"
     ],
     "includePlatforms": [],
     "excludePlatforms": [],

package/Runtime/Code/VoxelWorld/VoxelCompressUtil.cs

@@ -1,11 +1,15 @@
-using System.IO;
+using System;
+using System.IO;
 using System.IO.Compression;
+using Code.Zstd;
 
 public static class VoxelCompressUtil {
+	private const ulong ZstdScratchBufferSize = 1024 * 128;
+	
 	/// <summary>
 	/// Compress the given stream to a byte array.
 	/// </summary>
-	public static byte[] CompressToByteArray(Stream stream) {
+	public static byte[] CompressToByteArrayV1(Stream stream) {
 		using var compressedStream = new MemoryStream();
 		using var compressor = new DeflateStream(compressedStream, CompressionMode.Compress);
 		
@@ -22,7 +26,7 @@ public static class VoxelCompressUtil {
 	/// Decompress the compressed byte array into a new MemoryStream. The returned
 	/// stream must be disposed once done.
 	/// </summary>
-	public static MemoryStream DecompressToMemoryStream(byte[] data) {
+	public static MemoryStream DecompressToMemoryStreamV1(byte[] data) {
 		var decompressedStream = new MemoryStream();
 		
 		using var compressedStream = new MemoryStream(data);
@@ -34,4 +38,23 @@ public static class VoxelCompressUtil {
 
 		return decompressedStream;
 	}
+	
+	/// <summary>
+	/// Compress the given data to a byte array.
+	/// </summary>
+	public static byte[] CompressToByteArrayV2(ReadOnlySpan<byte> data) {
+		using var zstd = new Zstd(ZstdScratchBufferSize);
+		var compressed = zstd.Compress(data, Zstd.MaxCompressionLevel);
+		return compressed;
+	}
+
+	/// <summary>
+	/// Decompress the compressed byte array into a new MemoryStream. The returned
+	/// stream must be disposed once done.
+	/// </summary>
+	public static MemoryStream DecompressToMemoryStreamV2(ReadOnlySpan<byte> data) {
+		using var zstd = new Zstd(ZstdScratchBufferSize);
+		var decompressed = zstd.Decompress(data);
+		return new MemoryStream(decompressed, false);
+	}
 }

package/Runtime/Code/VoxelWorld/VoxelWorldChunk.cs

@@ -443,7 +443,7 @@ namespace VoxelWorldStuff {
         /// </summary>
         public void WriteTemporaryCollision(Vector3 position, bool hasCollision) {
             if (hasCollision) {
-                VoxelWorldCollision.MakeCollider(this, position, Vector3Int.one);
+                VoxelWorldCollision.MakeCollider(this, Vector3Int.FloorToInt(position) + Vector3.one / 2, Vector3Int.one);
             } else {
                 VoxelWorldCollision.RemoveSingleVoxelCollision(this, position);
             }

package/Runtime/Code/VoxelWorld/WorldSaveFile.cs

@@ -6,7 +6,6 @@ using UnityEngine.Profiling;
 using VoxelData = System.UInt16;
 using BlockId = System.UInt16;
 
-
 [Serializable]
 [LuauAPI]
 [CreateAssetMenu(fileName = "VoxelWorldSaveFile", menuName = "Airship/VoxelWorld/VoxelWorldSaveFile", order = 0)]
@@ -15,6 +14,7 @@ public class WorldSaveFile : ScriptableObject {
     public List<BlockIdToScopedName> blockIdToScopeName = new();
 
     public byte[] chunksCompressed;
+    [HideInInspector] public bool chunksCompressedV2;
 
     [Serializable]
     public struct BlockIdToScopedName {
@@ -131,9 +131,6 @@ public class WorldSaveFile : ScriptableObject {
         }
     }
 
-
-
-
     public BlockId GetFileBlockIdFromStringId(string blockTypeId) {
         foreach (var pair in this.blockIdToScopeName) {
             if (pair.name == blockTypeId) {
@@ -216,7 +213,10 @@ public class WorldSaveFile : ScriptableObject {
         }
         
         // Compress:
-        chunksCompressed = VoxelCompressUtil.CompressToByteArray(memStream);
+        var buffer = memStream.GetBuffer();
+        var bufferSpan = new ReadOnlySpan<byte>(buffer, 0, (int)memStream.Length);
+        chunksCompressed = VoxelCompressUtil.CompressToByteArrayV2(bufferSpan);
+        chunksCompressedV2 = true;
         
         Profiler.EndSample();
 
@@ -299,7 +299,9 @@ public class WorldSaveFile : ScriptableObject {
             
             // Decompress and deserialize chunks:
             Profiler.BeginSample("DecompressChunks");
-            using var decompressedStream = VoxelCompressUtil.DecompressToMemoryStream(chunksCompressed);
+            using var decompressedStream = chunksCompressedV2
+                ? VoxelCompressUtil.DecompressToMemoryStreamV2(chunksCompressed)
+                : VoxelCompressUtil.DecompressToMemoryStreamV1(chunksCompressed);
             Profiler.EndSample();
 
             var reader = new BinaryReader(decompressedStream);

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gg.easy.airship",
-  "version": "0.1.2136",
+  "version": "0.1.2137",
   "displayName": "Airship",
   "unity": "2021.3",
   "unityRelease": "12f1",