solve 'edge' case and pass cancellation token

Infra/Buffers/ArrayOwner.cs

@@ -24,7 +24,8 @@ public class ArrayOwner<T> : IBuffer<T> where T : unmanaged
 
     public ref T this[int index] => ref _buffer[index];
 
-    public Span<T> Span => _buffer;
+    public Span<T> Span => _buffer.AsSpan(0, Length);
+    public Memory<T> Memory => _buffer.AsMemory(0, Length);
 
     public T[] Array => _buffer;
 

Infra/Buffers/IBuffer.cs

@@ -5,6 +5,8 @@ public interface IBuffer<T> : IDisposable where T : unmanaged
     ref T this[int index] { get; }
         
     Span<T> Span { get; }
+        
+    Memory<T> Memory { get; }
     
     int Length { get; }
 }

Infra/Buffers/ImmovableMemory.cs

@@ -4,34 +4,48 @@ using System.Runtime.InteropServices;
 
 namespace StitchATon2.Infra.Buffers;
 
-internal sealed unsafe class ImmovableMemory<T> : MemoryManager<T> where T : unmanaged
+internal sealed unsafe class ImmovableMemory<T> : MemoryManager<T>, IBuffer<T> where T : unmanaged
 {
-    private readonly T* _pointer;
-    private readonly int _length;
+    internal readonly T* Pointer;
     private bool _disposed;
 
-    public ImmovableMemory(int count)
+    public ImmovableMemory(int length)
     {
-        _pointer = (T*)NativeMemory.Alloc((nuint)count, (nuint)Unsafe.SizeOf<T>());
-        _length = count;
+        Pointer = (T*)NativeMemory.Alloc((nuint)length, (nuint)Unsafe.SizeOf<T>());
+        Length = length;
     }
     
     protected override void Dispose(bool disposing)
     {
-        if (!_disposed)
-        {
-            NativeMemory.Free(_pointer);
-            _disposed = true;
-        }
+        if (_disposed) return;
+        NativeMemory.Free(Pointer);
+        _disposed = true;
     }
 
     public override Span<T> GetSpan()
-        => new(_pointer, _length);
+        => _disposed 
+            ? throw new ObjectDisposedException(nameof(ImmovableMemory<T>)) 
+            : new Span<T>(Pointer, Length);
 
     public override MemoryHandle Pin(int elementIndex = 0)
-        => new(_pointer + elementIndex);
+        => _disposed
+            ? throw new ObjectDisposedException(nameof(ImmovableMemory<T>))
+            : new MemoryHandle(Pointer + elementIndex);
 
     public override void Unpin()
     {
     }
+
+    public ref T this[int index]
+    {
+        get
+        {
+            if (_disposed) throw new ObjectDisposedException(nameof(ImmovableMemory<T>));
+            return ref Unsafe.AsRef<T>(Pointer + index);
+        }
+    }
+
+    public Span<T> Span => GetSpan();
+    
+    public int Length { get; }
 }

Infra/Buffers/MemoryAllocator.cs

@@ -6,7 +6,7 @@ namespace StitchATon2.Infra.Buffers;
 public static class MemoryAllocator
 {
     public static IBuffer<T> Allocate<T>(int count) where T : unmanaged
-        => new UnmanagedMemory<T>(count);
+        => new ImmovableMemory<T>(count);
     
     public static IMemoryOwner<T> AllocateManaged<T>(int count)
         => MemoryPool<T>.Shared.Rent(count);
@@ -14,31 +14,23 @@ public static class MemoryAllocator
     public static ArrayOwner<T> AllocateArray<T>(int count) where T : unmanaged
         => new(ArrayPool<T>.Shared, count);
 
-    public static MemoryManager<T> AllocateImmovable<T>(int count) where T : unmanaged
-        => new ImmovableMemory<T>(count);
-
     public static unsafe IBuffer<T> Clone<T>(this IBuffer<T> buffer) where T : unmanaged
     {
-        if (buffer is UnmanagedMemory<T> unmanagedMemory)
-        {
-            var newBuffer = new UnmanagedMemory<T>(buffer.Length);
-            var byteCount = (uint)(Unsafe.SizeOf<T>() * buffer.Length);
-            Unsafe.CopyBlock(newBuffer.Pointer, unmanagedMemory.Pointer, byteCount);
-            return newBuffer;
-        }
+        if (buffer is not ImmovableMemory<T> unmanagedMemory)
+            throw new NotSupportedException();
         
-        throw new NotSupportedException();
+        var newBuffer = new ImmovableMemory<T>(buffer.Length);
+        var byteCount = (uint)(Unsafe.SizeOf<T>() * buffer.Length);
+        Unsafe.CopyBlock(newBuffer.Pointer, unmanagedMemory.Pointer, byteCount);
+        return newBuffer;
     }
 
     public static unsafe void Copy<T>(this IBuffer<T> source, IBuffer<T> destination, int count) where T : unmanaged
     {
-        if (source is UnmanagedMemory<T> sourceBuffer && destination is UnmanagedMemory<T> destinationBuffer)
-        {
-            var byteCount = (uint)(Unsafe.SizeOf<T>() * count);
-            Unsafe.CopyBlock(destinationBuffer.Pointer, sourceBuffer.Pointer, byteCount);
-            return;
-        }
+        if (source is not ImmovableMemory<T> sourceBuffer || destination is not ImmovableMemory<T> destinationBuffer)
+            throw new NotSupportedException();
         
-        throw new NotSupportedException();
+        var byteCount = (uint)(Unsafe.SizeOf<T>() * count);
+        Unsafe.CopyBlock(destinationBuffer.Pointer, sourceBuffer.Pointer, byteCount);
     }
 }

Infra/Buffers/UnmanagedMemory.cs

@@ -7,11 +7,13 @@ namespace StitchATon2.Infra.Buffers;
 /// Provide non-thread safe anti GC contiguous memory. 
 /// </summary>
 /// <typeparam name="T"></typeparam>
+[Obsolete("Use immovable memory instead")]
 internal sealed unsafe class UnmanagedMemory<T> : IBuffer<T> where T : unmanaged
 {
     internal readonly T* Pointer;
     private bool _disposed;
-    
+
+    public Memory<T> Memory => throw new NotImplementedException();
     public int Length { get; }
 
     public ref T this[int index] => ref Unsafe.AsRef<T>(Pointer + index);