dotnet 9 and sequential id

added more tests
fixed condition for base32 encode test
2025-08-01 22:21:42 +04:00 · 2024-08-15 22:00:49 +04:00 · 2024-08-15 21:01:46 +04:00 · 2024-08-15 20:51:18 +04:00 · 2024-08-15 20:22:45 +04:00 · 2024-08-15 20:14:38 +04:00
20 changed files with 963 additions and 48 deletions
--- a/.gitea/workflows/publish-nuget.yaml
+++ b/.gitea/workflows/publish-nuget.yaml
@@ -16,7 +16,7 @@ jobs:
    - name: Setup .NET
      uses: https://github.com/actions/setup-dotnet@v3
      with:
-        dotnet-version: 8.x
+        dotnet-version: 9.x

    - name: Restore dependencies
      run: dotnet restore Core/Core.csproj
--- a/.gitea/workflows/test-dotnet.yaml
+++ b/.gitea/workflows/test-dotnet.yaml
@@ -21,7 +21,7 @@ jobs:
    - name: Setup .NET
      uses: https://github.com/actions/setup-dotnet@v3
      with:
-        dotnet-version: 8.x
+        dotnet-version: 9.x

    - name: Restore dependencies
      run: dotnet restore
@@ -30,12 +30,12 @@ jobs:
      run: dotnet build --no-restore

    - name: Test
-      run: dotnet test --no-build --verbosity normal --logger trx --results-directory "TestResults-8.x"
+      run: dotnet test --no-build --verbosity normal --logger trx --results-directory "TestResults-9.x"

    - name: Upload dotnet test results
      uses: actions/upload-artifact@v3
      with:
-        name: dotnet-results-8.x
-        path: TestResults-8.x
+        name: dotnet-results-9.x
+        path: TestResults-9.x
        if: ${{ always() }}
        retention-days: 30
--- a/Core.Tests/Base32Conversions/Decode.cs
+++ b/Core.Tests/Base32Conversions/Decode.cs
@@ -36,7 +36,7 @@ public class Decode
        var actualBytesArray = Base32.Decode(str);
        actualBytesArray.Should().Equal(expected);
    }
-    
+
    [Theory]
    [InlineData("ZFXJMF5N====", new byte[] { 0b11001001, 0b01101110, 0b10010110, 0b00010111, 0b10101101, })]
    [InlineData("CPIKTMY=====", new byte[] { 0b00010011, 0b11010000, 0b10101001, 0b10110011, })]
@@ -56,7 +56,7 @@ public class Decode
        var actualBytesArray = Base32.Decode(testString);
        actualBytesArray.Should().Equal(expected);
    }
-    
+
    [Theory]
    [InlineData("  ")]
    [InlineData("hg2515i3215")]
@@ -72,7 +72,7 @@ public class Decode
    [Theory]
    [InlineData(null)]
    [InlineData("")]
-    public void WhenCalledWithNullString_ShouldReturnEmptyArray(string testString)
+    public void WhenCalledWithNullString_ShouldReturnEmptyArray(string? testString)
    {
        Base32.Decode(testString).Should().BeEmpty();
    }
--- a/Core.Tests/Base32Conversions/Encode.cs
+++ b/Core.Tests/Base32Conversions/Encode.cs
@@ -23,17 +23,22 @@ public class Encode
    [InlineData("GSHXGB5ORKNDSFLSU2YWALI=")]
    [InlineData("TMFSC64ZZNPQSNGCFIODS7TR")]
    [InlineData("ZTDUBU4QZFFMDJKBII334EIB")]
+    [InlineData("2IO2HTALCXZWCBD2AAAAAAAAAAAA====")]
+    [InlineData("WXYEOQUZULMCY6ZQTDOLTRUZZMKQ====")]
+    [InlineData("FG4M3ZQM3TVWDMBUP5L7N7V3JS7KBM2E")]
    public void WhenDecodedFromString_ShouldBeEncodedToTheSameString(string testString)
    {
        var resultBytes = Base32.Decode(testString);
        var resultString = Base32.Encode(resultBytes);

-        resultString.Should().BeEquivalentTo(testString);
+        resultString.Should().Be(testString);
    }

    [Theory]
    [InlineData("FG4M3ZQM3TVWDMBUP5L7N7V3JS7KBM2E", new byte[] { 0x29, 0xb8, 0xcd, 0xe6, 0x0c, 0xdc, 0xeb, 0x61, 0xb0, 0x34, 0x7f, 0x57, 0xf6, 0xfe, 0xbb, 0x4c, 0xbe, 0xa0, 0xb3, 0x44, })]
    [InlineData("WXYEOQUZULMCY6ZQTDOLTRUZZMKQ====", new byte[] { 0xb5, 0xf0, 0x47, 0x42, 0x99, 0xa2, 0xd8, 0x2c, 0x7b, 0x30, 0x98, 0xdc, 0xb9, 0xc6, 0x99, 0xcb, 0x15, })]
+    [InlineData("2IO2HTALCXZWCBD2AAAAAAAAAAAA====", new byte[] { 0xd2, 0x1d, 0xa3, 0xcc, 0x0b, 0x15, 0xf3, 0x61, 0x04, 0x7a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, })]
+    [InlineData("2IO2HTALCXZWCBD2AAAAAAAA", new byte[] { 0xd2, 0x1d, 0xa3, 0xcc, 0x0b, 0x15, 0xf3, 0x61, 0x04, 0x7a, 0x00, 0x00, 0x00, 0x00, 0x00, })]
    [InlineData("2IO2HTALCXZWCBD2", new byte[] { 0xd2, 0x1d, 0xa3, 0xcc, 0x0b, 0x15, 0xf3, 0x61, 0x04, 0x7a, })]
    [InlineData("ZFXJMF5N", new byte[] { 0b11001001, 0b01101110, 0b10010110, 0b00010111, 0b10101101, })]
    [InlineData("CPIKTMY=", new byte[] { 0b00010011, 0b11010000, 0b10101001, 0b10110011, })]
@@ -43,14 +48,27 @@ public class Encode
    {
        var str = Base32.Encode(testArray);
        str.Should().Be(expected);
-    } 
-    
+    }
+
    [Theory]
    [InlineData(new byte[] { })]
    [InlineData(null)]
-    public void WhenCalledWithEmptyByteArray_ShouldReturnEmptyString(byte[] testArray)
+    public void WhenCalledWithEmptyByteArray_ShouldReturnEmptyString(byte[]? testArray)
    {
        var actualBase32 = Base32.Encode(testArray);
-        actualBase32?.Should().Be(string.Empty);
+        actualBase32.Should().Be(string.Empty);
+    }
+
+    [Theory]
+    [InlineData(new byte[] { })]
+    [InlineData(null)]
+    public void WhenCalledWithEmptyByteArray_ShouldReturnZeroAndNotChangeOutput(byte[]? testArray)
+    {
+        char[] output = ['1', '2', '3', '4'];
+
+        var charsWritten = Base32.Encode(testArray, output);
+
+        charsWritten.Should().Be(0);
+        output.Should().Equal(['1', '2', '3', '4']);
    }
 }
--- a/Core.Tests/Base64UrlConversions/Decode.cs
+++ b/Core.Tests/Base64UrlConversions/Decode.cs
@@ -50,4 +50,36 @@ public class Decode
        var result = Base64Url.Decode(testString);
        result.Should().BeEquivalentTo(expected);
    }
+
+    [Theory]
+    [InlineData("  ")]
+    [InlineData("hg2&515i3215")]
+    [InlineData("hg712)21")]
+    [InlineData("hg712f 21")]
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Performance", "CA1806:Do not ignore method results", Justification = "Test case")]
+    public void WhenCalledWithInvalidString_ShouldThrowFormatException(string testString)
+    {
+        Action action = () => Base64Url.Decode(testString);
+        action.Should().Throw<FormatException>();
+    }
+
+    [Theory]
+    [InlineData("5QrdUxDUV CAEGw8pvLsEw")]
+    [InlineData("6nE2uKQ4$0ar9kpmybgkdw")]
+    [InlineData("PyD6zwDqXkG*S1HPsp41wQ")]
+    [InlineData("!dOlPOh3wEe9PlyQgTMt2g")]
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Performance", "CA1806:Do not ignore method results", Justification = "Test case")]
+    public void WhenCalledWithInvalidGuidString_ShouldThrowFormatException(string testString)
+    {
+        Action action = () => Base64Url.DecodeGuid(testString);
+        action.Should().Throw<FormatException>();
+    }
+
+    [Theory]
+    [InlineData(null)]
+    [InlineData("")]
+    public void WhenCalledWithNullString_ShouldReturnEmptyArray(string testString)
+    {
+        Base64Url.Decode(testString).Should().BeEmpty();
+    }
 }
--- a/Core.Tests/Base64UrlConversions/Encode.cs
+++ b/Core.Tests/Base64UrlConversions/Encode.cs
@@ -29,4 +29,26 @@ public class Encode
        var result = Base64Url.Encode(testBytes);
        result.Should().Be(expected);
    }
+
+    [Theory]
+    [InlineData(new byte[] { })]
+    [InlineData(null)]
+    public void WhenCalledWithEmptyByteArray_ShouldReturnEmptyString(byte[] testArray)
+    {
+        var actualBase32 = Base64Url.Encode(testArray);
+        actualBase32.Should().Be(string.Empty);
+    }
+
+    [Theory]
+    [InlineData(new byte[] { })]
+    [InlineData(null)]
+    public void WhenCalledWithEmptyByteArray_ShouldReturnZeroAndNotChangeOutput(byte[] testArray)
+    {
+        char[] output = ['1', '2', '3', '4'];
+
+        var charsWritten = Base64Url.Encode(testArray, output);
+
+        charsWritten.Should().Be(0);
+        output.Should().Equal(['1', '2', '3', '4']);
+    }
 }
--- a/Core.Tests/Core.Tests.csproj
+++ b/Core.Tests/Core.Tests.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
-    <TargetFramework>net8.0</TargetFramework>
+    <TargetFramework>net9.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
    
@@ -15,13 +15,13 @@

  <ItemGroup>
    <PackageReference Include="FluentAssertions" Version="6.12.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.6.0" />
-    <PackageReference Include="xunit" Version="2.4.2" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.5">
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.14.1" />
+    <PackageReference Include="xunit" Version="2.9.3" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="3.1.3">
      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
      <PrivateAssets>all</PrivateAssets>
    </PackageReference>
-    <PackageReference Include="coverlet.collector" Version="6.0.0">
+    <PackageReference Include="coverlet.collector" Version="6.0.4">
      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
      <PrivateAssets>all</PrivateAssets>
    </PackageReference>
--- a/Core.Tests/GuidV8Tests/NewGuid.cs
+++ b/Core.Tests/GuidV8Tests/NewGuid.cs
@@ -0,0 +1,226 @@
+namespace Just.Core.Tests.GuidV8Tests;
+
+public class NewGuid
+{
+    [Theory]
+    [InlineData(RngEntropy.Weak,
+        -25000000, -10000000, -5000000, -2000000, -1000000, -500000, -250000, -100000, -25000, -10000, -5000,
+        -2500, -1000, -500, -499, -497, -450, -300, -200, -50, -1, 0, 1, 2, 5, 10, 20, 50, 100, 200, 350, 500, 1000,
+        2500, 5000, 10000, 25000, 100000, 250000, 500000, 1000000, 2000000, 5000000, 10000000, 100000000, 250000000)]
+    [InlineData(RngEntropy.Strong,
+        -25000000, -10000000, -5000000, -2000000, -1000000, -500000, -250000, -100000, -25000, -10000, -5000,
+        -2500, -1000, -500, -499, -497, -450, -300, -200, -50, -1, 0, 1, 2, 5, 10, 20, 50, 100, 200, 350, 500, 1000,
+        2500, 5000, 10000, 25000, 100000, 250000, 500000, 1000000, 2000000, 5000000, 10000000, 100000000, 250000000)]
+    [InlineData(RngEntropy.Weak,
+        -9863, -9740, -9214, -8878, -8674, -8652, -8640, -8565, -8518, -8449,
+        -8390, -8193, -8108, -7808, -7501, -7203, -7133, -7020, -6983, -6855,
+        -6576, -6162, -5630, -5505, -5472, -5382, -4706, -4680, -4509, -4454,
+        -4314, -3920, -3251, -3233, -3116, -2792, -2685, -2574, -2338, -2173,
+        -1934, -1914, -1528, -1483, -1410, -870, -757, -730, -263, -220,
+        151, 426, 588, 970, 1213, 1269, 1376, 1397, 1450, 1770,
+        2063, 2577, 2750, 2860, 3139, 3161, 3488, 3630, 3774, 4004,
+        4163, 4198, 4366, 4662, 4746, 4879, 5467, 5601, 5912, 5979,
+        6128, 6277, 6323, 6437, 6699, 6853, 7556, 7776, 7795, 8099,
+        8336, 8592, 8682, 8683, 8818, 8904, 9375, 9466, 9551, 9708)]
+    [InlineData(RngEntropy.Strong,
+        -9863, -9740, -9214, -8878, -8674, -8652, -8640, -8565, -8518, -8449,
+        -8390, -8193, -8108, -7808, -7501, -7203, -7133, -7020, -6983, -6855,
+        -6576, -6162, -5630, -5505, -5472, -5382, -4706, -4680, -4509, -4454,
+        -4314, -3920, -3251, -3233, -3116, -2792, -2685, -2574, -2338, -2173,
+        -1934, -1914, -1528, -1483, -1410, -870, -757, -730, -263, -220,
+        151, 426, 588, 970, 1213, 1269, 1376, 1397, 1450, 1770,
+        2063, 2577, 2750, 2860, 3139, 3161, 3488, 3630, 3774, 4004,
+        4163, 4198, 4366, 4662, 4746, 4879, 5467, 5601, 5912, 5979,
+        6128, 6277, 6323, 6437, 6699, 6853, 7556, 7776, 7795, 8099,
+        8336, 8592, 8682, 8683, 8818, 8904, 9375, 9466, 9551, 9708)]
+    [InlineData(RngEntropy.Weak,
+        5635912, 6673780, 17277183, 17512959, 19098799, 21672621, 30581958, 30824885, 31874213, 35192781,
+        36337094, 37752116, 38387215, 39154682, 40525427, 52288093, 55218356, 59065156, 65231785, 75430932,
+        76289058, 79078058, 85770685, 85925884, 94726743, 94864163, 95781967, 96150006, 96482085, 102570414,
+        107768232, 110571078, 110680108, 117974892, 119800380, 126381415, 135895862, 140034471, 149039187, 150906974,
+        156853001, 160514433, 166446323, 170148965, 171759448, 176494242, 184537553, 188558155, 197194403, 197615804,
+        201195323, 202294490, 203040975, 203331457, 205016944, 213460258, 217072025, 217185345, 231344025, 232390198,
+        235053215, 240175073, 245030721, 252275255, 252310334, 277070940, 277359970, 280624756, 288601124, 292427106,
+        292563035, 299285016, 303834917, 310357836, 315078337, 316367236, 318311758, 318873972, 319675272, 321784171,
+        324204294, 327667283, 330287252, 338438172, 349863360, 360777768, 366398711, 368637150, 368776734, 371900343,
+        379094084, 379818879, 381448333, 381814627, 382393101, 382483709, 385600870, 389455134, 396115960, 399364095)]
+    [InlineData(RngEntropy.Strong,
+        5635912, 6673780, 17277183, 17512959, 19098799, 21672621, 30581958, 30824885, 31874213, 35192781,
+        36337094, 37752116, 38387215, 39154682, 40525427, 52288093, 55218356, 59065156, 65231785, 75430932,
+        76289058, 79078058, 85770685, 85925884, 94726743, 94864163, 95781967, 96150006, 96482085, 102570414,
+        107768232, 110571078, 110680108, 117974892, 119800380, 126381415, 135895862, 140034471, 149039187, 150906974,
+        156853001, 160514433, 166446323, 170148965, 171759448, 176494242, 184537553, 188558155, 197194403, 197615804,
+        201195323, 202294490, 203040975, 203331457, 205016944, 213460258, 217072025, 217185345, 231344025, 232390198,
+        235053215, 240175073, 245030721, 252275255, 252310334, 277070940, 277359970, 280624756, 288601124, 292427106,
+        292563035, 299285016, 303834917, 310357836, 315078337, 316367236, 318311758, 318873972, 319675272, 321784171,
+        324204294, 327667283, 330287252, 338438172, 349863360, 360777768, 366398711, 368637150, 368776734, 371900343,
+        379094084, 379818879, 381448333, 381814627, 382393101, 382483709, 385600870, 389455134, 396115960, 399364095)]
+    public void Guids_Differing_By_Minutes_Should_Be_Sortable(RngEntropy entropy, params int[] seconds)
+    {
+        var rng = new Random(25);
+        var referenceTime = new DateTime(2024, 05, 17, 15, 36, 13, 771, DateTimeKind.Utc);
+        SortedList<DateTime, Guid> expected = new(seconds.Length);
+        foreach (var s in seconds)
+        {
+            var timestamp = referenceTime.AddMinutes(s);
+            expected.Add(timestamp, GuidV8.NewGuid(timestamp, entropy));
+        }
+
+        var sut = expected.Values.ToArray();
+        rng.Shuffle(sut);
+
+        sut.Order().Should().Equal(expected.Select(x => x.Value));
+        sut.OrderBy(x => x.ToString()).Should().Equal(expected.Select(x => x.Value));
+
+        sut.OrderDescending().Should().Equal(expected.Reverse().Select(x => x.Value));
+        sut.OrderByDescending(x => x.ToString()).Should().Equal(expected.Reverse().Select(x => x.Value));
+    }
+
+    [Theory]
+    [InlineData(RngEntropy.Weak,
+        -250000000, -25000000, -10000000, -5000000, -2000000, -1000000, -500000, -250000, -100000, -25000, -10000, -5000,
+        -2500, -1000, -500, -499, -497, -450, -300, -200, -50, -1, 0, 1, 2, 5, 10, 20, 50, 100, 200, 350, 500, 1000,
+        2500, 5000, 10000, 25000, 100000, 250000, 500000, 1000000, 2000000, 5000000, 10000000, 100000000, 2100000000)]
+    [InlineData(RngEntropy.Strong,
+        -250000000, -25000000, -10000000, -5000000, -2000000, -1000000, -500000, -250000, -100000, -25000, -10000, -5000,
+        -2500, -1000, -500, -499, -497, -450, -300, -200, -50, -1, 0, 1, 2, 5, 10, 20, 50, 100, 200, 350, 500, 1000,
+        2500, 5000, 10000, 25000, 100000, 250000, 500000, 1000000, 2000000, 5000000, 10000000, 100000000, 2100000000)]
+    [InlineData(RngEntropy.Weak,
+        -9863, -9740, -9214, -8878, -8674, -8652, -8640, -8565, -8518, -8449,
+        -8390, -8193, -8108, -7808, -7501, -7203, -7133, -7020, -6983, -6855,
+        -6576, -6162, -5630, -5505, -5472, -5382, -4706, -4680, -4509, -4454,
+        -4314, -3920, -3251, -3233, -3116, -2792, -2685, -2574, -2338, -2173,
+        -1934, -1914, -1528, -1483, -1410, -870, -757, -730, -263, -220,
+        151, 426, 588, 970, 1213, 1269, 1376, 1397, 1450, 1770,
+        2063, 2577, 2750, 2860, 3139, 3161, 3488, 3630, 3774, 4004,
+        4163, 4198, 4366, 4662, 4746, 4879, 5467, 5601, 5912, 5979,
+        6128, 6277, 6323, 6437, 6699, 6853, 7556, 7776, 7795, 8099,
+        8336, 8592, 8682, 8683, 8818, 8904, 9375, 9466, 9551, 9708)]
+    [InlineData(RngEntropy.Strong,
+        -9863, -9740, -9214, -8878, -8674, -8652, -8640, -8565, -8518, -8449,
+        -8390, -8193, -8108, -7808, -7501, -7203, -7133, -7020, -6983, -6855,
+        -6576, -6162, -5630, -5505, -5472, -5382, -4706, -4680, -4509, -4454,
+        -4314, -3920, -3251, -3233, -3116, -2792, -2685, -2574, -2338, -2173,
+        -1934, -1914, -1528, -1483, -1410, -870, -757, -730, -263, -220,
+        151, 426, 588, 970, 1213, 1269, 1376, 1397, 1450, 1770,
+        2063, 2577, 2750, 2860, 3139, 3161, 3488, 3630, 3774, 4004,
+        4163, 4198, 4366, 4662, 4746, 4879, 5467, 5601, 5912, 5979,
+        6128, 6277, 6323, 6437, 6699, 6853, 7556, 7776, 7795, 8099,
+        8336, 8592, 8682, 8683, 8818, 8904, 9375, 9466, 9551, 9708)]
+    [InlineData(RngEntropy.Weak,
+        6629058, 24114993, 40561510, 46245969, 46876997, 48747281, 80489854, 110237218, 117445694, 118974860,
+        135132579, 141760591, 149114066, 158322437, 159065333, 164925904, 173848639, 175086337, 175704556, 176335514,
+        200302773, 207133553, 230088723, 234521706, 239587338, 263755571, 264571928, 290118284, 292346548, 319322378,
+        320988273, 322638028, 324110126, 326855208, 332533719, 336668313, 350798512, 366520367, 380595181, 405033666,
+        410929500, 414099488, 417697882, 421269768, 431907031, 435262715, 442168482, 449797406, 458508845, 489039529,
+        503344305, 514934509, 537515867, 555210743, 563951463, 578783864, 580560518, 580902916, 605801607, 635231377,
+        636537435, 637241486, 676077268, 691630262, 696158602, 714007596, 715537265, 718873134, 724266320, 741049828,
+        749379956, 757561933, 758668417, 761735205, 770349479, 797570403, 805896481, 809050934, 821655964, 821980469,
+        830824227, 840429528, 851772315, 859717719, 859763860, 867675943, 912124563, 914880620, 923914294, 930298008,
+        932610035, 937468680, 945565998, 949277691, 949397209, 951283050, 953249971, 953953188, 976210158, 982233484, 982233485)]
+    [InlineData(RngEntropy.Strong,
+        6629058, 24114993, 40561510, 46245969, 46876997, 48747281, 80489854, 110237218, 117445694, 118974860,
+        135132579, 141760591, 149114066, 158322437, 159065333, 164925904, 173848639, 175086337, 175704556, 176335514,
+        200302773, 207133553, 230088723, 234521706, 239587338, 263755571, 264571928, 290118284, 292346548, 319322378,
+        320988273, 322638028, 324110126, 326855208, 332533719, 336668313, 350798512, 366520367, 380595181, 405033666,
+        410929500, 414099488, 417697882, 421269768, 431907031, 435262715, 442168482, 449797406, 458508845, 489039529,
+        503344305, 514934509, 537515867, 555210743, 563951463, 578783864, 580560518, 580902916, 605801607, 635231377,
+        636537435, 637241486, 676077268, 691630262, 696158602, 714007596, 715537265, 718873134, 724266320, 741049828,
+        749379956, 757561933, 758668417, 761735205, 770349479, 797570403, 805896481, 809050934, 821655964, 821980469,
+        830824227, 840429528, 851772315, 859717719, 859763860, 867675943, 912124563, 914880620, 923914294, 930298008,
+        932610035, 937468680, 945565998, 949277691, 949397209, 951283050, 953249971, 953953188, 976210158, 982233484, 982233485)]
+    public void Guids_Differing_By_Seconds_Should_Be_Sortable(RngEntropy entropy, params int[] seconds)
+    {
+        var rng = new Random(25);
+        var referenceTime = new DateTime(2024, 05, 17, 15, 36, 13, 771, DateTimeKind.Utc);
+        SortedList<DateTime, Guid> expected = new(seconds.Length);
+        foreach (var s in seconds)
+        {
+            var timestamp = referenceTime.AddSeconds(s);
+            expected.Add(timestamp, GuidV8.NewGuid(timestamp, entropy));
+        }
+
+        var sut = expected.Values.ToArray();
+        rng.Shuffle(sut);
+
+        sut.Order().Should().Equal(expected.Select(x => x.Value));
+        sut.OrderBy(x => x.ToString()).Should().Equal(expected.Select(x => x.Value));
+
+        sut.OrderDescending().Should().Equal(expected.Reverse().Select(x => x.Value));
+        sut.OrderByDescending(x => x.ToString()).Should().Equal(expected.Reverse().Select(x => x.Value));
+    }
+
+    [Theory]
+    [InlineData(RngEntropy.Weak,
+        -250000000, -25000000, -10000000, -5000000, -2000000, -1000000, -500000, -250000, -100000, -25000, -10000, -5000,
+        -2500, -1000, -500, -499, -497, -450, -300, -200, -50, -1, 0, 1, 2, 5, 10, 20, 50, 100, 200, 350, 500, 1000,
+        2500, 5000, 10000, 25000, 100000, 250000, 500000, 1000000, 2000000, 5000000, 10000000, 100000000, 2100000000)]
+    [InlineData(RngEntropy.Strong,
+        -250000000, -25000000, -10000000, -5000000, -2000000, -1000000, -500000, -250000, -100000, -25000, -10000, -5000,
+        -2500, -1000, -500, -499, -497, -450, -300, -200, -50, -1, 0, 1, 2, 5, 10, 20, 50, 100, 200, 350, 500, 1000,
+        2500, 5000, 10000, 25000, 100000, 250000, 500000, 1000000, 2000000, 5000000, 10000000, 100000000, 2100000000)]
+    [InlineData(RngEntropy.Weak,
+        -9863, -9740, -9214, -8878, -8674, -8652, -8640, -8565, -8518, -8449,
+        -8390, -8193, -8108, -7808, -7501, -7203, -7133, -7020, -6983, -6855,
+        -6576, -6162, -5630, -5505, -5472, -5382, -4706, -4680, -4509, -4454,
+        -4314, -3920, -3251, -3233, -3116, -2792, -2685, -2574, -2338, -2173,
+        -1934, -1914, -1528, -1483, -1410, -870, -757, -730, -263, -220,
+        151, 426, 588, 970, 1213, 1269, 1376, 1397, 1450, 1770,
+        2063, 2577, 2750, 2860, 3139, 3161, 3488, 3630, 3774, 4004,
+        4163, 4198, 4366, 4662, 4746, 4879, 5467, 5601, 5912, 5979,
+        6128, 6277, 6323, 6437, 6699, 6853, 7556, 7776, 7795, 8099,
+        8336, 8592, 8682, 8683, 8818, 8904, 9375, 9466, 9551, 9708)]
+    [InlineData(RngEntropy.Strong,
+        -9863, -9740, -9214, -8878, -8674, -8652, -8640, -8565, -8518, -8449,
+        -8390, -8193, -8108, -7808, -7501, -7203, -7133, -7020, -6983, -6855,
+        -6576, -6162, -5630, -5505, -5472, -5382, -4706, -4680, -4509, -4454,
+        -4314, -3920, -3251, -3233, -3116, -2792, -2685, -2574, -2338, -2173,
+        -1934, -1914, -1528, -1483, -1410, -870, -757, -730, -263, -220,
+        151, 426, 588, 970, 1213, 1269, 1376, 1397, 1450, 1770,
+        2063, 2577, 2750, 2860, 3139, 3161, 3488, 3630, 3774, 4004,
+        4163, 4198, 4366, 4662, 4746, 4879, 5467, 5601, 5912, 5979,
+        6128, 6277, 6323, 6437, 6699, 6853, 7556, 7776, 7795, 8099,
+        8336, 8592, 8682, 8683, 8818, 8904, 9375, 9466, 9551, 9708)]
+    [InlineData(RngEntropy.Weak,
+        6629058, 24114993, 40561510, 46245969, 46876997, 48747281, 80489854, 110237218, 117445694, 118974860,
+        135132579, 141760591, 149114066, 158322437, 159065333, 164925904, 173848639, 175086337, 175704556, 176335514,
+        200302773, 207133553, 230088723, 234521706, 239587338, 263755571, 264571928, 290118284, 292346548, 319322378,
+        320988273, 322638028, 324110126, 326855208, 332533719, 336668313, 350798512, 366520367, 380595181, 405033666,
+        410929500, 414099488, 417697882, 421269768, 431907031, 435262715, 442168482, 449797406, 458508845, 489039529,
+        503344305, 514934509, 537515867, 555210743, 563951463, 578783864, 580560518, 580902916, 605801607, 635231377,
+        636537435, 637241486, 676077268, 691630262, 696158602, 714007596, 715537265, 718873134, 724266320, 741049828,
+        749379956, 757561933, 758668417, 761735205, 770349479, 797570403, 805896481, 809050934, 821655964, 821980469,
+        830824227, 840429528, 851772315, 859717719, 859763860, 867675943, 912124563, 914880620, 923914294, 930298008,
+        932610035, 937468680, 945565998, 949277691, 949397209, 951283050, 953249971, 953953188, 976210158, 982233484, 982233485)]
+    [InlineData(RngEntropy.Strong,
+        6629058, 24114993, 40561510, 46245969, 46876997, 48747281, 80489854, 110237218, 117445694, 118974860,
+        135132579, 141760591, 149114066, 158322437, 159065333, 164925904, 173848639, 175086337, 175704556, 176335514,
+        200302773, 207133553, 230088723, 234521706, 239587338, 263755571, 264571928, 290118284, 292346548, 319322378,
+        320988273, 322638028, 324110126, 326855208, 332533719, 336668313, 350798512, 366520367, 380595181, 405033666,
+        410929500, 414099488, 417697882, 421269768, 431907031, 435262715, 442168482, 449797406, 458508845, 489039529,
+        503344305, 514934509, 537515867, 555210743, 563951463, 578783864, 580560518, 580902916, 605801607, 635231377,
+        636537435, 637241486, 676077268, 691630262, 696158602, 714007596, 715537265, 718873134, 724266320, 741049828,
+        749379956, 757561933, 758668417, 761735205, 770349479, 797570403, 805896481, 809050934, 821655964, 821980469,
+        830824227, 840429528, 851772315, 859717719, 859763860, 867675943, 912124563, 914880620, 923914294, 930298008,
+        932610035, 937468680, 945565998, 949277691, 949397209, 951283050, 953249971, 953953188, 976210158, 982233484, 982233485)]
+    public void Guids_Differing_By_Milliseconds_Should_Be_Sortable(RngEntropy entropy, params int[] seconds)
+    {
+        var rng = new Random(26);
+        var referenceTime = new DateTime(2024, 05, 17, 15, 36, 13, 771, DateTimeKind.Utc);
+        SortedList<DateTime, Guid> expected = new(seconds.Length);
+        foreach (var s in seconds)
+        {
+            var timestamp = referenceTime.AddMilliseconds(s);
+            expected.Add(timestamp, GuidV8.NewGuid(timestamp, entropy));
+        }
+
+        var sut = expected.Values.ToArray();
+        rng.Shuffle(sut);
+
+        sut.Order().Should().Equal(expected.Select(x => x.Value));
+        sut.OrderBy(x => x.ToString()).Should().Equal(expected.Select(x => x.Value));
+
+        sut.OrderDescending().Should().Equal(expected.Reverse().Select(x => x.Value));
+        sut.OrderByDescending(x => x.ToString()).Should().Equal(expected.Reverse().Select(x => x.Value));
+    }
+}
--- a/Core.Tests/SeqIdTests/NextId.cs
+++ b/Core.Tests/SeqIdTests/NextId.cs
@@ -0,0 +1,140 @@
+namespace Just.Core.Tests.SeqIdTests;
+
+public class NextId
+{
+    private static readonly DateTime TestEpoch = new(2025, 1, 1, 0, 0, 0, DateTimeKind.Utc);
+    private readonly SeqId _seqId = new(TestEpoch);
+
+    private const int TimestampShift = 22; // 63 - 41 = 22
+    private const long TimestampMask = 0x1FFFFFFFFFF; // 41 bits mask
+    private const int SeqShift = 14; // TimestampShift - 8 = 14
+    private const long SeqMask = 0xFF; // 8 bits mask
+    private const long RandMask = 0x3FFF; // 14 bits mask (since 2^14 = 16384)
+
+    [Fact]
+    public void NextId_ShouldHaveCorrectBitStructure()
+    {
+        // Arrange
+        var time = TestEpoch.AddMilliseconds(500);
+
+        // Act
+        long id = _seqId.Next(time);
+
+        // Assert
+        long timestampPart = (id >> TimestampShift) & TimestampMask;
+        long sequencePart = (id >> SeqShift) & SeqMask;
+        long randomPart = id & RandMask;
+
+        timestampPart.Should().Be(500);
+        sequencePart.Should().Be(0);
+        randomPart.Should().BeInRange(0, RandMask);
+    }
+
+    [Fact]
+    public void NextId_ShouldIncrementSequenceForSameTimestamp()
+    {
+        // Arrange
+        var time = TestEpoch.AddMilliseconds(100);
+
+        // Act
+        long id1 = _seqId.Next(time);
+        long id2 = _seqId.Next(time);
+
+        // Assert
+        long sequence1 = (id1 >> SeqShift) & SeqMask;
+        long sequence2 = (id2 >> SeqShift) & SeqMask;
+
+        sequence2.Should().Be(sequence1 + 1);
+    }
+
+    [Fact]
+    public void NextId_ShouldResetSequenceForNewTimestamp()
+    {
+        // Arrange
+        var time1 = TestEpoch.AddMilliseconds(100);
+        var time2 = time1.AddMilliseconds(1);
+
+        // Act
+        _ = _seqId.Next(time1); // Sequence increments to 0
+        _ = _seqId.Next(time1); // Sequence increments to 1
+        long id = _seqId.Next(time2); // Should reset to 0
+
+        // Assert
+        long sequence = (id >> SeqShift) & SeqMask;
+        sequence.Should().Be(0);
+    }
+
+    [Fact]
+    public void NextId_ShouldThrowWhenTimestampDecreases()
+    {
+        // Arrange
+        var time1 = TestEpoch.AddMilliseconds(200);
+        var time2 = TestEpoch.AddMilliseconds(100);
+
+        // Act & Assert
+        _seqId.Next(time1); // First call sets last timestamp
+        Action act = () => _seqId.Next(time2);
+        act.Should().Throw<InvalidOperationException>()
+            .WithMessage("Refused to create new SeqId. Last timestamp is in the future.");
+    }
+
+    [Fact]
+    public void NextId_ShouldThrowWhenSequenceExhausted()
+    {
+        // Arrange
+        var time = TestEpoch.AddMilliseconds(200);
+
+        // Act & Assert
+        for (int i = 0; i < 255; i++)
+        {
+            _seqId.Next(time); // Exhauste sequence
+        }
+        Action act = () => _seqId.Next(time);
+        act.Should().Throw<IndexOutOfRangeException>()
+            .WithMessage("Refused to create new SeqId. Sequence exhausted.");
+    }
+
+    [Fact]
+    public void NextId_WithStrongEntropy_ShouldSetLower14Bits()
+    {
+        // Arrange
+        var time = TestEpoch.AddMilliseconds(300);
+
+        // Act
+        long id = _seqId.Next(time, RngEntropy.Strong);
+
+        // Assert
+        long randomPart = id & RandMask;
+        randomPart.Should().BeInRange(0, RandMask);
+    }
+
+    [Fact]
+    public void NextId_WithWeakEntropy_ShouldSetLower14Bits()
+    {
+        // Arrange
+        var time = TestEpoch.AddMilliseconds(400);
+
+        // Act
+        long id = _seqId.Next(time, RngEntropy.Weak);
+
+        // Assert
+        long randomPart = id & RandMask;
+        randomPart.Should().BeInRange(0, RandMask);
+    }
+
+    [Fact]
+    public void DefaultInstance_NextId_ShouldUseDefaultEpoch()
+    {
+        // Arrange
+        var now = DateTime.UtcNow;
+        var defaultEpoch = new DateTime(2025, 1, 1, 0, 0, 0, DateTimeKind.Utc);
+        long expectedTimestamp = (long)(now - defaultEpoch).TotalMilliseconds;
+
+        // Act
+        long id = SeqId.NextId();
+
+        // Assert
+        long timestampPart = (id >> TimestampShift) & TimestampMask;
+        timestampPart.Should().BeCloseTo(expectedTimestamp & TimestampMask, 1); // Mask handles overflow
+    }
+}
--- a/Core.Tests/SystemIOStreamExtensionsTests/Populate.cs
+++ b/Core.Tests/SystemIOStreamExtensionsTests/Populate.cs
@@ -0,0 +1,58 @@
+using Just.Core.Extensions;
+
+namespace Just.Core.Tests.SystemIOStreamExtensionsTests;
+
+public class Populate
+{
+    [Theory]
+    [InlineData(0, 0)]
+    [InlineData(0, 1)]
+    [InlineData(0, 3)]
+    [InlineData(0, 5)]
+    [InlineData(3, 0)]
+    [InlineData(3, 1)]
+    [InlineData(3, 5)]
+    [InlineData(5, 0)]
+    [InlineData(5, 1)]
+    [InlineData(5, 5)]
+    public void WhenCalled_ShouldPopulateSpecifiedRange(int offset, int length)
+    {
+        byte[] streamContent = [0x01, 0x02, 0x03, 0x04, 0x05,];
+        using var stream = new MemoryStream(streamContent);
+        var buffer = new byte[10];
+
+        stream.Populate(buffer, offset, length);
+
+        buffer.Skip(offset).Take(length).Should().Equal(streamContent.Take(length));
+    }
+
+    [Theory]
+    [InlineData(new byte[]{ 0x01, 0x02, 0x03, 0x04, }, 4)]
+    [InlineData(new byte[]{ 0x01, 0x02, 0x03, 0x04, 0x05, }, 4)]
+    [InlineData(new byte[]{ 0x01, 0x02, 0x03, 0x04, 0x05, }, 5)]
+    [InlineData(new byte[]{ 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, }, 5)]
+    public void WhenStreamContainsSameOrGreaterAmmountOfItems_ShouldPopulateBuffer(byte[] streamContent, int bufferSize)
+    {
+        using var stream = new MemoryStream(streamContent);
+        var buffer = new byte[bufferSize];
+
+        stream.Populate(buffer);
+
+        buffer.Should().Equal(streamContent.Take(bufferSize));
+    }
+
+    [Theory]
+    [InlineData(new byte[]{ 0x01, 0x02, 0x03, 0x04, }, 5)]
+    [InlineData(new byte[]{ 0x01, 0x02, 0x03, 0x04, 0x05, }, 6)]
+    [InlineData(new byte[]{ 0x01, 0x02, 0x03, 0x04, 0x05, }, 10)]
+    [InlineData(new byte[]{ 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, }, 9)]
+    public void WhenStreamContainsLessItems_ShouldThrowEndOfStreamException(byte[] streamContent, int bufferSize)
+    {
+        using var stream = new MemoryStream(streamContent);
+        var buffer = new byte[bufferSize];
+
+        Action action = () => stream.Populate(buffer);
+
+        action.Should().Throw<EndOfStreamException>();
+    }
+}
--- a/Core.Tests/SystemIOStreamExtensionsTests/PopulateAsync.cs
+++ b/Core.Tests/SystemIOStreamExtensionsTests/PopulateAsync.cs
@@ -0,0 +1,72 @@
+using Just.Core.Extensions;
+
+namespace Just.Core.Tests.SystemIOStreamExtensionsTests;
+
+public class PopulateAsync
+{
+    [Fact]
+    public async Task WhenCancellationRequested_ShouldThrowOperationCanceledException()
+    {
+        using var cts = new CancellationTokenSource();
+        byte[] streamContent = [0x01, 0x02, 0x03, 0x04, 0x05,];
+        using var stream = new MemoryStream(streamContent);
+        var buffer = new byte[5];
+
+        Func<Task> action = async () => await stream.PopulateAsync(buffer, cts.Token);
+        cts.Cancel();
+
+        await action.Should().ThrowAsync<OperationCanceledException>();
+    }
+
+    [Theory]
+    [InlineData(0, 0)]
+    [InlineData(0, 1)]
+    [InlineData(0, 3)]
+    [InlineData(0, 5)]
+    [InlineData(3, 0)]
+    [InlineData(3, 1)]
+    [InlineData(3, 5)]
+    [InlineData(5, 0)]
+    [InlineData(5, 1)]
+    [InlineData(5, 5)]
+    public async Task WhenCalled_ShouldPopulateSpecifiedRange(int offset, int length)
+    {
+        byte[] streamContent = [0x01, 0x02, 0x03, 0x04, 0x05,];
+        using var stream = new MemoryStream(streamContent);
+        var buffer = new byte[10];
+
+        await stream.PopulateAsync(buffer, offset, length);
+
+        buffer.Skip(offset).Take(length).Should().Equal(streamContent.Take(length));
+    }
+
+    [Theory]
+    [InlineData(new byte[]{ 0x01, 0x02, 0x03, 0x04, }, 4)]
+    [InlineData(new byte[]{ 0x01, 0x02, 0x03, 0x04, 0x05, }, 4)]
+    [InlineData(new byte[]{ 0x01, 0x02, 0x03, 0x04, 0x05, }, 5)]
+    [InlineData(new byte[]{ 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, }, 5)]
+    public async Task WhenStreamContainsSameOrGreaterAmmountOfItems_ShouldPopulateBuffer(byte[] streamContent, int bufferSize)
+    {
+        using var stream = new MemoryStream(streamContent);
+        var buffer = new byte[bufferSize];
+
+        await stream.PopulateAsync(buffer);
+
+        buffer.Should().Equal(streamContent.Take(bufferSize));
+    }
+
+    [Theory]
+    [InlineData(new byte[]{ 0x01, 0x02, 0x03, 0x04, }, 5)]
+    [InlineData(new byte[]{ 0x01, 0x02, 0x03, 0x04, 0x05, }, 6)]
+    [InlineData(new byte[]{ 0x01, 0x02, 0x03, 0x04, 0x05, }, 10)]
+    [InlineData(new byte[]{ 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, }, 9)]
+    public async Task WhenStreamContainsLessItems_ShouldThrowEndOfStreamException(byte[] streamContent, int bufferSize)
+    {
+        using var stream = new MemoryStream(streamContent);
+        var buffer = new byte[bufferSize];
+
+        Func<Task> action = async () => await stream.PopulateAsync(buffer);
+
+        await action.Should().ThrowAsync<EndOfStreamException>();
+    }
+}
--- a/Core/Base32.cs
+++ b/Core/Base32.cs
@@ -4,26 +4,28 @@ public static class Base32
 {
    public const string Alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
    public const char Padding = '=';
+    public const int MaxBytesStack = 250;

    [Pure]
    public static string Encode(ReadOnlySpan<byte> input)
    {
-        if (input.Length == 0)
-        {
-            return string.Empty;
-        }
+        if (input.IsEmpty) return string.Empty;

        int outLength = 8 * ((input.Length + 4) / 5);
-        Span<char> output = stackalloc char[outLength];
+        Span<char> output = input.Length <= MaxBytesStack
+            ? stackalloc char[outLength]
+            : new char[outLength];

        _ = Encode(input, output);

        return new string(output);
    }
-    
+
    [Pure]
    public static int Encode(ReadOnlySpan<byte> input, Span<char> output)
    {
+        if (input.IsEmpty) return 0;
+
        int i = 0;
        ReadOnlySpan<char> alphabet = Alphabet;
        for (int offset = 0; offset < input.Length;)
@@ -45,10 +47,14 @@ public static class Base32
    [Pure]
    public static byte[] Decode(ReadOnlySpan<char> input)
    {
+        input = input.TrimEnd(Padding);
        if (input.IsEmpty) return [];
-        
-        Span<byte> output = stackalloc byte[5 * input.Length / 8];
-        
+
+        var outputLength = 5 * ((input.Length + 7) / 8);
+        Span<byte> output = outputLength <= MaxBytesStack
+            ? stackalloc byte[outputLength]
+            : new byte[outputLength];
+
        var size = Decode(input, output);

        return output[..size].ToArray();
@@ -58,7 +64,14 @@ public static class Base32
    public static int Decode(ReadOnlySpan<char> input, Span<byte> output)
    {
        input = input.TrimEnd(Padding);
-        Span<char> inputspan = stackalloc char[input.Length];
+
+        var outputLength = 5 * ((input.Length + 7) / 8);
+        output = output[..outputLength];
+        output.Clear();
+
+        Span<char> inputspan = outputLength <= MaxBytesStack
+            ? stackalloc char[input.Length]
+            : new char[input.Length];
        input.ToUpperInvariant(inputspan);

        int bitIndex = 0;
@@ -77,7 +90,7 @@ public static class Base32
            {
                throw new FormatException("Provided string contains invalid characters.");
            }
-            
+
            bitPos = 5 - bitIndex;
            outBitPos = 8 - outputBits;
            bits = bitPos < outBitPos ? bitPos : outBitPos;
@@ -104,7 +117,6 @@ public static class Base32
        return outputIndex + (outputBits + 7) / 8;
    }

-    
    // returns the number of bytes that were output
    [Pure]
    private static int GetNextGroup(ReadOnlySpan<byte> input, ref int offset, out byte a, out byte b, out byte c, out byte d, out byte e, out byte f, out byte g, out byte h)
--- a/Core/Base64Url.cs
+++ b/Core/Base64Url.cs
@@ -95,6 +95,8 @@ public static class Base64Url

    [Pure] public static int Encode(ReadOnlySpan<byte> input, Span<char> output)
    {
+        if (input.IsEmpty) return 0;
+
        var charlen = 8 * ((input.Length + 5) / 6);
        Span<char> chars = stackalloc char[charlen];
        Convert.TryToBase64Chars(input, chars, out int charsWritten);
--- a/Core/Collections/ImmutableSequence.cs
+++ b/Core/Collections/ImmutableSequence.cs
@@ -0,0 +1,90 @@
+using System.Collections;
+using System.Collections.Immutable;
+
+namespace Just.Core.Collections;
+
+public class ImmutableSequence<T> :
+    IEnumerable<T>,
+    IReadOnlyList<T>,
+    IEquatable<ImmutableSequence<T>>
+{
+    private static readonly int InitialHash = typeof(ImmutableSequence<T>).GetHashCode();
+    private static readonly Func<T?, T?, bool> CompareItem = EqualityComparer<T>.Default.Equals;
+    private readonly ImmutableList<T> _values;
+
+    public ImmutableSequence(ImmutableList<T> values) => _values = values;
+    public ImmutableSequence() : this(ImmutableArray<T>.Empty)
+    {
+    }
+    public ImmutableSequence(IEnumerable<T> values)
+    {
+        _values = [..values];
+    }
+    public ImmutableSequence(ReadOnlySpan<T> values) : this(ImmutableList.Create(values))
+    {
+    }
+
+    public bool IsEmpty => _values.IsEmpty;
+    public int Count => _values.Count;
+    public T this[int index] => _values[index];
+    public T this[Index index] => _values[index];
+    public ImmutableSequence<T> this[Range range]
+    {
+        get
+        {
+            var (offset, count) = range.GetOffsetAndLength(_values.Count);
+            return ConstructNew(_values.GetRange(offset, count));
+        }
+    }
+
+    protected virtual ImmutableSequence<T> ConstructNew(ImmutableList<T> values) => new(values);
+
+    public ImmutableSequence<T> Add(T value) => ConstructNew([.._values, value]);
+    public ImmutableSequence<T> AddFront(T value) => ConstructNew([value, .._values]);
+
+    public ImmutableList<T>.Enumerator GetEnumerator() => _values.GetEnumerator();
+    IEnumerator<T> IEnumerable<T>.GetEnumerator() => ((IEnumerable<T>)_values).GetEnumerator();
+    IEnumerator IEnumerable.GetEnumerator() => ((IEnumerable)_values).GetEnumerator();
+
+    public override string ToString() => string.Join(Environment.NewLine, _values);
+
+    public virtual bool Equals([NotNullWhen(true)] ImmutableSequence<T>? other)
+    {
+        if (ReferenceEquals(this, other))
+        {
+            return true;
+        }
+
+        if (_values.Count != other?._values.Count)
+        {
+            return false;
+        }
+
+        for (int i = 0; i < _values.Count; i++)
+        {
+            if (!CompareItem(_values[i], other._values[i]))
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    public override bool Equals([NotNullWhen(true)] object? obj) => Equals(obj as ImmutableSequence<T>);
+    public override int GetHashCode()
+    {
+        HashCode hash = new();
+        hash.Add(InitialHash);
+
+        foreach (var value in _values)
+        {
+            hash.Add(value);
+        }
+
+        return hash.ToHashCode();
+    }
+
+    public static bool operator ==(ImmutableSequence<T>? left, ImmutableSequence<T>? right) => left is null ? right is null : left.Equals(right);
+    public static bool operator !=(ImmutableSequence<T>? left, ImmutableSequence<T>? right) => !(left == right);
+}
--- a/Core/Core.csproj
+++ b/Core/Core.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
-    <TargetFramework>net8.0</TargetFramework>
+    <TargetFrameworks>net8.0;net9.0</TargetFrameworks>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
    <AssemblyName>Just.Core</AssemblyName>
@@ -10,7 +10,7 @@
    <Description>Small .Net library with useful helper classes, functions and extensions.</Description>
    <PackageTags>extensions;helpers;helper-functions</PackageTags>
    <Authors>JustFixMe</Authors>
-    <Copyright>Copyright (c) 2023 JustFixMe</Copyright>
+    <Copyright>Copyright (c) 2023-2025 JustFixMe</Copyright>
    <PackageLicenseFile>LICENSE</PackageLicenseFile>
    <PackageReadmeFile>README.md</PackageReadmeFile>
    <RepositoryUrl>https://github.com/JustFixMe/Just.Core/</RepositoryUrl>
--- a/Core/Extensions/SystemIOStreamExtensions.cs
+++ b/Core/Extensions/SystemIOStreamExtensions.cs
@@ -1,46 +1,114 @@
 namespace Just.Core.Extensions;

+/// <summary>
+/// Provides extension methods for <see cref="Stream"/> to fully populate buffers.
+/// </summary>
 public static class SystemIOStreamExtensions
 {
+    /// <summary>
+    /// Reads data from the stream until the specified section of the buffer is filled.
+    /// </summary>
+    /// <param name="stream">The stream to read from</param>
+    /// <param name="buffer">The buffer to populate</param>
+    /// <param name="offset">The starting offset in the buffer</param>
+    /// <param name="length">The number of bytes to read</param>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="stream"/> is null</exception>
+    /// <exception cref="ArgumentOutOfRangeException">Thrown when <paramref name="offset"/> or <paramref name="length"/> is invalid</exception>
+    /// <exception cref="EndOfStreamException">Thrown if the stream ends before filling the buffer</exception>
+    /// <exception cref="IOException">Thrown for I/O errors during reading</exception>
    public static void Populate(this Stream stream, byte[] buffer, int offset, int length)
        => stream.Populate(buffer.AsSpan(offset, length));
+    /// <summary>
+    /// Reads data from the stream until the entire buffer is filled.
+    /// </summary>
+    /// <param name="stream">The stream to read from</param>
+    /// <param name="buffer">The buffer to populate</param>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="stream"/> is null</exception>
+    /// <exception cref="EndOfStreamException">Thrown if the stream ends before filling the buffer</exception>
+    /// <exception cref="IOException">Thrown for I/O errors during reading</exception>
    public static void Populate(this Stream stream, byte[] buffer)
        => stream.Populate(buffer.AsSpan());
+    /// <summary>
+    /// Reads data from the stream until the specified span is filled.
+    /// </summary>
+    /// <param name="stream">The stream to read from</param>
+    /// <param name="buffer">The span to populate</param>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="stream"/> is null</exception>
+    /// <exception cref="EndOfStreamException">Thrown if the stream ends before filling the buffer</exception>
+    /// <exception cref="IOException">Thrown for I/O errors during reading</exception>
    public static void Populate(this Stream stream, Span<byte> buffer)
    {
-        do
-        {
-            var readed = stream.Read(buffer);
+        ArgumentNullException.ThrowIfNull(stream);

-            if (readed == 0)
+        while (!buffer.IsEmpty)
+        {
+            var bytesRead = stream.Read(buffer);
+
+            if (bytesRead == 0)
            {
                throw new EndOfStreamException();
            }

-            buffer = buffer[readed..];
+            buffer = buffer[bytesRead..];
        }
-        while (buffer.Length > 0);
    }

-    public static async ValueTask PopulateAsync(this Stream stream, byte[] buffer, CancellationToken cancellationToken = default)
-        => await stream.PopulateAsync(buffer.AsMemory(), cancellationToken);
-    public static async ValueTask PopulateAsync(this Stream stream, byte[] buffer, int offset, int length, CancellationToken cancellationToken = default)
-        => await stream.PopulateAsync(buffer.AsMemory(offset, length), cancellationToken);
+    /// <summary>
+    /// Asynchronously reads data from the stream until the entire buffer is filled.
+    /// </summary>
+    /// <param name="stream">The stream to read from</param>
+    /// <param name="buffer">The buffer to populate</param>
+    /// <param name="cancellationToken">Cancellation token</param>
+    /// <returns>A ValueTask representing the asynchronous operation</returns>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="stream"/> is null</exception>
+    /// <exception cref="EndOfStreamException">Thrown if the stream ends before filling the buffer</exception>
+    /// <exception cref="OperationCanceledException">Thrown if canceled via cancellation token</exception>
+    /// <exception cref="IOException">Thrown for I/O errors during reading</exception>
+    public static ValueTask PopulateAsync(this Stream stream, byte[] buffer, CancellationToken cancellationToken = default)
+        => stream.PopulateAsync(buffer.AsMemory(), cancellationToken);
+    /// <summary>
+    /// Asynchronously reads data from the stream until the specified section of the buffer is filled.
+    /// </summary>
+    /// <param name="stream">The stream to read from</param>
+    /// <param name="buffer">The buffer to populate</param>
+    /// <param name="offset">The starting offset in the buffer</param>
+    /// <param name="length">The number of bytes to read</param>
+    /// <param name="cancellationToken">Cancellation token</param>
+    /// <returns>A ValueTask representing the asynchronous operation</returns>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="stream"/> is null</exception>
+    /// <exception cref="ArgumentOutOfRangeException">Thrown when <paramref name="offset"/> or <paramref name="length"/> is invalid</exception>
+    /// <exception cref="EndOfStreamException">Thrown if the stream ends before filling the buffer</exception>
+    /// <exception cref="OperationCanceledException">Thrown if canceled via cancellation token</exception>
+    /// <exception cref="IOException">Thrown for I/O errors during reading</exception>
+    public static ValueTask PopulateAsync(this Stream stream, byte[] buffer, int offset, int length, CancellationToken cancellationToken = default)
+        => stream.PopulateAsync(buffer.AsMemory(offset, length), cancellationToken);
+    /// <summary>
+    /// Asynchronously reads data from the stream until the specified memory region is filled.
+    /// </summary>
+    /// <param name="stream">The stream to read from</param>
+    /// <param name="buffer">The memory region to populate</param>
+    /// <param name="cancellationToken">Cancellation token</param>
+    /// <returns>A ValueTask representing the asynchronous operation</returns>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="stream"/> is null</exception>
+    /// <exception cref="EndOfStreamException">Thrown if the stream ends before filling the buffer</exception>
+    /// <exception cref="OperationCanceledException">Thrown if canceled via cancellation token</exception>
+    /// <exception cref="IOException">Thrown for I/O errors during reading</exception>
    public static async ValueTask PopulateAsync(this Stream stream, Memory<byte> buffer, CancellationToken cancellationToken = default)
    {
-        do
+        ArgumentNullException.ThrowIfNull(stream);
+
+        while (!buffer.IsEmpty)
        {
            cancellationToken.ThrowIfCancellationRequested();

-            var readed = await stream.ReadAsync(buffer, cancellationToken);
+            var bytesRead = await stream.ReadAsync(buffer, cancellationToken).ConfigureAwait(false);

-            if (readed == 0)
+            if (bytesRead == 0)
            {
                throw new EndOfStreamException();
            }

-            buffer = buffer[readed..];
+            buffer = buffer[bytesRead..];
        }
-        while (buffer.Length > 0);
    }
 }
--- a/Core/GuidV8.cs
+++ b/Core/GuidV8.cs
@@ -0,0 +1,38 @@
+using System.Runtime.InteropServices;
+using System.Security.Cryptography;
+
+namespace Just.Core;
+
+public static class GuidV8
+{
+    [Pure, MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Guid NewGuid(RngEntropy entropy = RngEntropy.Strong) => NewGuid(DateTime.UtcNow, entropy);
+
+    [Pure]
+    public static Guid NewGuid(DateTime dateTime, RngEntropy entropy = RngEntropy.Strong)
+    {
+        var epoch = dateTime.Subtract(DateTime.UnixEpoch);
+        var timestamp = epoch.Ticks / (TimeSpan.TicksPerMillisecond / 10);
+
+        Span<byte> ts = stackalloc byte[8];
+        MemoryMarshal.Write(ts, timestamp);
+
+        Span<byte> bytes = stackalloc byte[16];
+
+        ts[0..2].CopyTo(bytes[4..6]);
+        ts[2..6].CopyTo(bytes[..4]);
+
+        if (entropy == RngEntropy.Strong)
+        {
+            RandomNumberGenerator.Fill(bytes[6..]);
+        }
+        else
+        {
+            Random.Shared.NextBytes(bytes[6..]);
+        }
+
+        bytes[7] = (byte)((bytes[7] & 0x0F) | 0x80);
+
+        return new Guid(bytes);
+    }
+}
--- a/Core/RngEntropy.cs
+++ b/Core/RngEntropy.cs
@@ -0,0 +1,16 @@
+namespace Just.Core;
+
+/// <summary>
+/// Specifies the quality of random entropy used in ID generation
+/// </summary>
+public enum RngEntropy
+{
+    /// <summary>
+    /// Cryptographically secure random numbers (slower but collision-resistant)
+    /// </summary>
+    Strong,
+    /// <summary>
+    /// Standard pseudo-random numbers (faster but less collision-resistant)
+    /// </summary>
+    Weak
+}
--- a/Core/SeqId.cs
+++ b/Core/SeqId.cs
@@ -0,0 +1,121 @@
+using System.Security.Cryptography;
+
+namespace Just.Core;
+
+/// <summary>
+/// Generates time-based sequential IDs with entropy
+/// <para>ID Structure (64 bits):</para>
+/// <list type="bullet">
+/// <item><description>[1 bit] Always 0 (positive signed longs)</description></item>
+/// <item><description>[41 bits] Milliseconds since epoch (covers ~69 years)</description></item>
+/// <item><description>[8 bits] Sequence counter (0-255 per millisecond)</description></item>
+/// <item><description>[14 bits] Random entropy (0-16383)</description></item>
+/// </list>
+/// </summary>
+/// <remarks>
+/// Important behaviors:
+/// <list type="bullet">
+/// <item><description>Guarantees monotonic ordering within same millisecond</description></item>
+/// <item><description>Throws <see cref="InvalidOperationException"/> on backward time jumps</description></item>
+/// <item><description>Sequence resets when timestamp advances</description></item>
+/// <item><description>Thread-safe through locking</description></item>
+/// </list>
+/// </remarks>
+public sealed class SeqId(DateTime epoch)
+{
+    private const int TimestampBits = 41;
+    private const int TimestampShift = 63 - TimestampBits;
+    private const long TimestampMask = 0x000001FF_FFFFFFFF;
+
+    private const int SeqBits = 8;
+    private const int SeqShift = TimestampShift - SeqBits;
+    private const long SeqMask = 0x00000000_000000FF;
+
+    private const int RandExclusiveUpper = 1 << SeqShift;
+
+    /// <summary>
+    /// Default epoch (2025-01-01 UTC) used for <see cref="Default"/> instance
+    /// </summary>
+    public static DateTime DefaultEpoch { get; } = new(2025, 1, 1, 0, 0, 0, DateTimeKind.Utc);
+    /// <summary>
+    /// Default instance using <see cref="DefaultEpoch"/>
+    /// </summary>
+    public static SeqId Default { get; } = new(DefaultEpoch);
+
+    /// <summary>
+    /// Generates ID using default instance and current UTC time
+    /// </summary>
+    /// <param name="entropy">Entropy quality (default: Strong)</param>
+    /// <returns>64-bit sequential ID with random component</returns>
+    /// <exception cref="IndexOutOfRangeException">
+    /// Thrown if more than 255 IDs generated in 1ms
+    /// </exception>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static long NextId(RngEntropy entropy = RngEntropy.Strong) => Default.Next(DateTime.UtcNow, entropy);
+
+#if NET9_0_OR_GREATER
+    private readonly Lock _lock = new();
+#else
+    private readonly object _lock = new();
+#endif
+
+    private readonly DateTime _epoch = epoch;
+    private int _seqId = 0;
+    private long _lastTimestamp = -1L;
+
+    /// <summary>
+    /// Generates next ID using current UTC time
+    /// </summary>
+    /// <param name="entropy">Entropy quality (default: Strong)</param>
+    /// <returns>64-bit sequential ID with random component</returns>
+    /// <exception cref="IndexOutOfRangeException">
+    /// Thrown if more than 255 IDs generated in 1ms
+    /// </exception>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public long Next(RngEntropy entropy = RngEntropy.Strong) => Next(DateTime.UtcNow, entropy);
+
+    /// <summary>
+    /// Generates next ID with explicit timestamp
+    /// </summary>
+    /// <param name="dateTime">Timestamp basis for ID generation</param>
+    /// <param name="entropy">Entropy quality (default: Strong)</param>
+    /// <returns>64-bit sequential ID with random component</returns>
+    /// <exception cref="InvalidOperationException">
+    /// Thrown if <paramref name="dateTime"/> is earlier than last used timestamp
+    /// </exception>
+    /// <exception cref="IndexOutOfRangeException">
+    /// Thrown if more than 255 IDs generated in 1ms
+    /// </exception>
+    public long Next(DateTime dateTime, RngEntropy entropy = RngEntropy.Strong)
+    {
+        var epoch = dateTime.Subtract(_epoch);
+        var timestamp = ((epoch.Ticks / TimeSpan.TicksPerMillisecond) & TimestampMask) << TimestampShift;
+
+        long currentSeq;
+        lock (_lock)
+        {
+            if (timestamp > _lastTimestamp)
+            {
+                _lastTimestamp = timestamp;
+                _seqId = 0;
+            }
+            else if (timestamp < _lastTimestamp)
+            {
+                throw new InvalidOperationException("Refused to create new SeqId. Last timestamp is in the future.");
+            }
+
+            if (_seqId == SeqMask)
+            {
+                throw new IndexOutOfRangeException("Refused to create new SeqId. Sequence exhausted.");
+            }
+
+            currentSeq = ((_seqId++) & SeqMask) << SeqShift;
+        }
+
+        long currentRand = entropy == RngEntropy.Strong
+            ? RandomNumberGenerator.GetInt32(RandExclusiveUpper)
+            : Random.Shared.Next(RandExclusiveUpper);
+
+        return timestamp | currentSeq | currentRand;
+    }
+}
--- a/2
+++ b/2
@@ -1,4 +1,4 @@
-Copyright (c) 2023 JustFixMe
+Copyright (c) 2023-2025 JustFixMe

 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
Author	SHA1	Message	Date
just	3665abaab8	dotnet 9 and sequential id All checks were successful .NET Test / test (push) Successful in 49s Details .NET Publish / publish (push) Successful in 41s Details	2025-08-01 22:21:42 +04:00
JustFixMe	2b68ba982d	added more tests All checks were successful .NET Test / test (push) Successful in 1m6s Details .NET Publish / publish (push) Successful in 38s Details	2024-08-15 22:00:49 +04:00
JustFixMe	43135a5ffb	fixed condition for base32 encode test All checks were successful .NET Test / test (push) Successful in 58s Details	2024-08-15 21:01:46 +04:00
JustFixMe	2afd66aa57	remove IEqualityOperators interface from ImmutableSequence All checks were successful .NET Test / test (push) Successful in 1m3s Details	2024-08-15 20:51:18 +04:00
JustFixMe	71ec5b2f35	* copyright update All checks were successful .NET Test / test (push) Successful in 1m2s Details	2024-08-15 20:22:45 +04:00
JustFixMe	30af957fc6	+ added ImmutableSequence All checks were successful .NET Test / test (push) Successful in 1m46s Details .NET Publish / publish (push) Successful in 52s Details	2024-08-15 20:14:38 +04:00
JustFixMe	d60b94dbaa	* fixed guid generation	2024-08-15 19:55:04 +04:00
JustFixMe	d565c48084	added custom time based guids All checks were successful .NET Test / test (push) Successful in 1m13s Details .NET Publish / publish (push) Successful in 51s Details	2024-05-17 20:40:51 +04:00