Change allocation IDs from int to uint

This doubles the range of allocation IDs from ~2.1B to ~4.3B before overflow.
Updated UnmanagedStringPool.lastAllocationId, PooledString.AllocationId,
EmptyStringAllocationId constant, and related method signatures.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: lookbusy1344

PooledString.cs

@@ -21,7 +21,7 @@ PooledString implements IDisposable to allow freeing its memory back to the pool
 /// Value type representing a string allocated from an unmanaged pool. Just a reference and an allocation ID, 12 bytes total.
 /// </summary>
 [System.Diagnostics.DebuggerDisplay("{ToString(),nq}")]
-public readonly record struct PooledString(UnmanagedStringPool Pool, int AllocationId) : IDisposable
+public readonly record struct PooledString(UnmanagedStringPool Pool, uint AllocationId) : IDisposable
 {
 	// NOTE this struct is technically immutable, but some methods mutate the underlying pool like SetAtPosition() and Free()
 	// It also implements IDisposable to call Free() automatically

Tests/ClearMethodTests.cs

@@ -171,7 +171,7 @@ public void Clear_PreservesIdCounter_NewAllocationsGetHigherIds()
 	public void Clear_OldIdsNeverReused()
 	{
 		// Arrange
-		var ids = new int[10];
+		var ids = new uint[10];
 		for (var i = 0; i < 5; i++) {
 			ids[i] = pool.Allocate($"String{i}").AllocationId;
 		}

Tests/UnmanagedStringPoolEdgeCaseTests.cs

@@ -385,9 +385,8 @@ public void GetAllocationInfo_InvalidId_ThrowsArgumentException()
 		using var pool = new UnmanagedStringPool(1024);
 
 		// Test various invalid IDs
-		Assert.Throws<ArgumentException>(() => pool.GetAllocationInfo(-1));
 		Assert.Throws<ArgumentException>(() => pool.GetAllocationInfo(999999));
-		Assert.Throws<ArgumentException>(() => pool.GetAllocationInfo(int.MaxValue));
+		Assert.Throws<ArgumentException>(() => pool.GetAllocationInfo(uint.MaxValue));
 	}
 
 	[Fact]
@@ -396,9 +395,8 @@ public void FreeString_InvalidId_NoException()
 		using var pool = new UnmanagedStringPool(1024);
 
 		// These should not throw - just be ignored
-		pool.FreeString(-1);
 		pool.FreeString(999999);
-		pool.FreeString(int.MaxValue);
+		pool.FreeString(uint.MaxValue);
 	}
 
 	[Fact]
@@ -492,7 +490,7 @@ public void EmptyStringPool_GetAllocationInfo_InvalidId_ThrowsArgumentException(
 	{
 		using var pool = new UnmanagedStringPool(1024);
 		Assert.Throws<ArgumentException>(() =>
-			pool.GetAllocationInfo(int.MaxValue));
+			pool.GetAllocationInfo(uint.MaxValue));
 	}
 
 	[Fact]
@@ -502,7 +500,7 @@ public void EmptyStringPool_FreeString_AnyId_NoEffect()
 		// These should not throw or cause issues
 		pool.FreeString(0);
 		pool.FreeString(1);
-		pool.FreeString(-1);
+		pool.FreeString(999999);
 	}
 
 	#endregion

UnmanagedStringPool.cs

@@ -35,7 +35,7 @@ heap allocation.
 /// </summary>
 public sealed class UnmanagedStringPool : IDisposable
 {
-	public const int EmptyStringAllocationId = 0; // Reserved for empty strings
+	public const uint EmptyStringAllocationId = 0; // Reserved for empty strings
 	private const int DefaultCollectionSize = 16; // Default size for internal collections
 	private const double FragmentationThreshold = 35.0; // Fragmentation threshold for triggering coalescing (percentage)
 	private const int MinimumBlocksForCoalescing = 8; // Minimum number of free blocks before considering coalescing
@@ -45,7 +45,7 @@ public sealed class UnmanagedStringPool : IDisposable
 	private IntPtr basePtr; // Base pointer to the unmanaged memory block
 	private int capacityBytes; // Total capacity in bytes of the pool
 	private int offsetFromBase; // Current offset from the base pointer, tracks how much space has been used
-	private int lastAllocationId; // Last allocation ID used, starts at 0. Monotonically increasing
+	private uint lastAllocationId; // Last allocation ID used, starts at 0. Monotonically increasing
 	private int freeOperationsSinceLastCoalesce; // Track recent coalescing to avoid excessive operations
 	private int totalFreeBlocks; // Total number of free blocks in the pool
 	private int totalFreeBytes; // Running total of free bytes to avoid recalculation
@@ -54,7 +54,7 @@ public sealed class UnmanagedStringPool : IDisposable
 	private readonly SortedList<int, List<FreeBlock>> freeBlocksBySize = new(DefaultCollectionSize);
 
 	// Central registry of allocated , keyed by allocation ID
-	private readonly Dictionary<int, AllocationInfo> allocations = new(DefaultCollectionSize);
+	private readonly Dictionary<uint, AllocationInfo> allocations = new(DefaultCollectionSize);
 
 	/// <summary>
 	/// Information about an allocated string. OffsetBytes is a convenience field, for when the block is freed. 16 bytes total
@@ -322,7 +322,7 @@ internal PooledString Allocate(int lengthChars)
 	/// Get allocation info for a valid allocation ID
 	/// </summary>
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
-	internal AllocationInfo GetAllocationInfo(int id)
+	internal AllocationInfo GetAllocationInfo(uint id)
 	{
 		if (id == EmptyStringAllocationId) {
 			return new(IntPtr.Zero, 0, 0);
@@ -336,7 +336,7 @@ internal AllocationInfo GetAllocationInfo(int id)
 	/// <summary>
 	/// Mark a string's memory as free for reuse
 	/// </summary>
-	internal void FreeString(int id)
+	internal void FreeString(uint id)
 	{
 		if (IsDisposed || id == EmptyStringAllocationId) {
 			// Empty strings do not need to be freed, they are always available
@@ -387,8 +387,9 @@ private static int AlignSize(int sizeBytes)
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	private PooledString RegisterAllocation(IntPtr ptr, int lengthChars, int offset)
 	{
-		if (lastAllocationId == int.MaxValue) {
-			// in the unlikely event we reach MaxValue (2 billion+ allocations) we cannot allocate more
+		if (lastAllocationId == uint.MaxValue) {
+			// in the unlikely event we reach MaxValue (4 billion+ allocations) we cannot allocate more
+			// it is more likely if the pool is long-lived and cleared repeatedly
 			throw new OutOfMemoryException("Allocation overflow");
 		}