Merge pull request #19 from BeshoyHindy/release/v0.1.0-alpha.5

Release v0.1.0-alpha.5

Author: BeshoyHindy

.gitignore

@@ -482,3 +482,6 @@ $RECYCLE.BIN/
 
 # Vim temporary swap files
 *.swp
+
+# Temporary test projects
+_temp-*

CHANGELOG.md

@@ -7,6 +7,22 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.1.0-alpha.5] - 2026-02-23
+
+### Changed
+
+- `BuildAwakeableId` rewritten with `System.Buffers.Text.Base64Url` — eliminates 3-4 intermediate string allocations per awakeable
+- Serialization hot path (`Run`, `SetState`, `Call`) uses `ArrayPool<byte>` rentals via `CopyToPooled` instead of `.ToArray()` — reduces GC pressure for typical 50-500 byte payloads
+- Replay journal entries use `RawMessage.DetachPayload()` ownership transfer — eliminates 1 `byte[]` copy per replayed entry
+- `CompletionManager` uses `CompletionSlot` discriminated union struct instead of `ConcurrentDictionary<int, object>` — eliminates boxing of `CompletionResult` on early completions
+- `ProtocolReader` single-segment fast paths for header parsing and payload copy — avoids `stackalloc` + `ReadOnlySequence.CopyTo` overhead on the common Kestrel path
+- `NegotiateVersion` uses explicit version substring checks instead of loop iteration
+
+### Fixed
+
+- NativeAotCounter sample port 9088 → 9086 to match CI integration test expectations
+- NativeAotSaga sample port 9089 → 9087 to match CI integration test expectations
+
 ## [0.1.0-alpha.4] - 2026-02-23
 
 ### Added

Directory.Build.props

@@ -10,7 +10,7 @@
 
     <!-- Shared NuGet package metadata -->
     <PropertyGroup>
-        <Version>0.1.0-alpha.4</Version>
+        <Version>0.1.0-alpha.5</Version>
         <Authors>Beshoy Hindy</Authors>
         <Company>Beshoy Hindy</Company>
         <Copyright>Copyright (c) 2026 Beshoy Hindy</Copyright>

samples/NativeAotCounter/Program.cs

@@ -6,6 +6,6 @@
 // Publish with: dotnet publish -c Release
 await RestateHost
     .CreateBuilder()
-    .WithPort(9088)
+    .WithPort(9086)
     .BuildAot(services => services.AddRestateGenerated(AppJsonContext.Default))
     .RunAsync();

samples/NativeAotSaga/Program.cs

@@ -6,6 +6,6 @@
 // Publish with: dotnet publish -c Release
 await RestateHost
     .CreateBuilder()
-    .WithPort(9089)
+    .WithPort(9087)
     .BuildAot(services => services.AddRestateGenerated(AppJsonContext.Default))
     .RunAsync();

src/Restate.Sdk/Hosting/RestateEndpointRouteBuilderExtensions.cs

@@ -37,12 +37,13 @@ public static class RestateEndpointRouteBuilderExtensions
         if (acceptHeader.Contains("*/*", StringComparison.Ordinal))
             return SupportedContentTypes[^1];
 
-        // Find the highest version we support that the client also supports
-        foreach (var supported in SupportedContentTypes)
-        {
-            if (acceptHeader.Contains(supported, StringComparison.OrdinalIgnoreCase))
-                return supported;
-        }
+        // Check version-specific substrings directly (highest priority first)
+        if (acceptHeader.Contains("endpointmanifest.v3", StringComparison.OrdinalIgnoreCase))
+            return SupportedContentTypes[0];
+        if (acceptHeader.Contains("endpointmanifest.v2", StringComparison.OrdinalIgnoreCase))
+            return SupportedContentTypes[1];
+        if (acceptHeader.Contains("endpointmanifest.v1", StringComparison.OrdinalIgnoreCase))
+            return SupportedContentTypes[2];
 
         return null; // No mutually supported version → 415
     }

src/Restate.Sdk/Internal/Journal/CompletionManager.cs

@@ -2,32 +2,70 @@
 
 namespace Restate.Sdk.Internal.Journal;
 
+/// <summary>
+///     Discriminated union that avoids boxing CompletionResult (a struct) when stored
+///     in ConcurrentDictionary. Holds either a TCS, a CompletionResult, or a TerminalException.
+/// </summary>
+internal readonly struct CompletionSlot
+{
+    private readonly object? _ref;
+    private readonly CompletionResult _result;
+    public SlotKind Kind { get; }
+
+    public enum SlotKind : byte { Tcs, Result, Failure }
+
+    public CompletionSlot(TaskCompletionSource<CompletionResult> tcs)
+    {
+        _ref = tcs;
+        _result = default;
+        Kind = SlotKind.Tcs;
+    }
+
+    public CompletionSlot(CompletionResult result)
+    {
+        _ref = null;
+        _result = result;
+        Kind = SlotKind.Result;
+    }
+
+    public CompletionSlot(TerminalException ex)
+    {
+        _ref = ex;
+        _result = default;
+        Kind = SlotKind.Failure;
+    }
+
+    public TaskCompletionSource<CompletionResult> Tcs => (TaskCompletionSource<CompletionResult>)_ref!;
+    public CompletionResult Result => _result;
+    public TerminalException Exception => (TerminalException)_ref!;
+}
+
 // ConcurrentDictionary is required here: the handler thread calls GetOrRegister while
 // ProcessIncomingMessagesAsync (running on a separate Task) calls TryComplete/TryFail.
 // Early completions are stored so notifications arriving before registration are not lost.
 internal sealed class CompletionManager
 {
-    private readonly ConcurrentDictionary<int, object> _slots = new();
+    private readonly ConcurrentDictionary<int, CompletionSlot> _slots = new();
 
     public TaskCompletionSource<CompletionResult> Register(int entryIndex)
     {
         var tcs = new TaskCompletionSource<CompletionResult>(TaskCreationOptions.RunContinuationsAsynchronously);
-        if (_slots.TryAdd(entryIndex, tcs))
+        if (_slots.TryAdd(entryIndex, new CompletionSlot(tcs)))
             return tcs;
 
         // Slot already occupied — either an early completion or a duplicate registration.
         if (_slots.TryRemove(entryIndex, out var slot))
         {
-            if (slot is TaskCompletionSource<CompletionResult>)
+            if (slot.Kind == CompletionSlot.SlotKind.Tcs)
                 throw new InvalidOperationException($"Entry {entryIndex} already registered");
 
             // Early completion arrived before registration — resolve the TCS immediately.
-            if (slot is CompletionResult result)
-                tcs.SetResult(result);
-            else if (slot is TerminalException ex)
-                tcs.SetException(ex);
+            if (slot.Kind == CompletionSlot.SlotKind.Result)
+                tcs.SetResult(slot.Result);
+            else if (slot.Kind == CompletionSlot.SlotKind.Failure)
+                tcs.SetException(slot.Exception);
 
-            _slots.TryAdd(entryIndex, tcs);
+            _slots.TryAdd(entryIndex, new CompletionSlot(tcs));
         }
 
         return tcs;
@@ -36,55 +74,56 @@ public TaskCompletionSource<CompletionResult> Register(int entryIndex)
     public TaskCompletionSource<CompletionResult> GetOrRegister(int entryIndex)
     {
         var slot = _slots.GetOrAdd(entryIndex,
-            static _ => new TaskCompletionSource<CompletionResult>(TaskCreationOptions.RunContinuationsAsynchronously));
+            static _ => new CompletionSlot(
+                new TaskCompletionSource<CompletionResult>(TaskCreationOptions.RunContinuationsAsynchronously)));
 
-        if (slot is TaskCompletionSource<CompletionResult> tcs)
-            return tcs;
+        if (slot.Kind == CompletionSlot.SlotKind.Tcs)
+            return slot.Tcs;
 
         // An early completion arrived before we registered — create a pre-resolved TCS.
         var earlyTcs = new TaskCompletionSource<CompletionResult>(TaskCreationOptions.RunContinuationsAsynchronously);
-        if (slot is CompletionResult result)
-            earlyTcs.SetResult(result);
-        else if (slot is TerminalException ex)
-            earlyTcs.SetException(ex);
+        if (slot.Kind == CompletionSlot.SlotKind.Result)
+            earlyTcs.SetResult(slot.Result);
+        else if (slot.Kind == CompletionSlot.SlotKind.Failure)
+            earlyTcs.SetException(slot.Exception);
 
         // Replace the stored value with the TCS (not strictly required, but keeps the dictionary clean).
-        _slots.TryUpdate(entryIndex, earlyTcs, slot);
+        _slots.TryUpdate(entryIndex, new CompletionSlot(earlyTcs), slot);
         return earlyTcs;
     }
 
     public bool TryComplete(int entryIndex, CompletionResult result)
     {
         if (_slots.TryRemove(entryIndex, out var slot))
         {
-            if (slot is TaskCompletionSource<CompletionResult> tcs)
-                return tcs.TrySetResult(result);
+            if (slot.Kind == CompletionSlot.SlotKind.Tcs)
+                return slot.Tcs.TrySetResult(result);
         }
 
         // No handler registered yet — store the result for later delivery.
-        _slots.TryAdd(entryIndex, result);
+        _slots.TryAdd(entryIndex, new CompletionSlot(result));
         return true;
     }
 
     public bool TryFail(int entryIndex, ushort code, string message)
     {
         if (_slots.TryRemove(entryIndex, out var slot))
         {
-            if (slot is TaskCompletionSource<CompletionResult> tcs)
-                return tcs.TrySetException(new TerminalException(message, code));
+            if (slot.Kind == CompletionSlot.SlotKind.Tcs)
+                return slot.Tcs.TrySetException(new TerminalException(message, code));
         }
 
         // No handler registered yet — store the failure for later delivery.
-        _slots.TryAdd(entryIndex, new TerminalException(message, code));
+        _slots.TryAdd(entryIndex, new CompletionSlot(new TerminalException(message, code)));
         return true;
     }
 
     public void CancelAll()
     {
         foreach (var pair in _slots)
         {
-            if (pair.Value is TaskCompletionSource<CompletionResult> tcs)
-                tcs.TrySetCanceled();
+            if (pair.Value.Kind == CompletionSlot.SlotKind.Tcs)
+                pair.Value.Tcs.TrySetCanceled();
         }
 
         _slots.Clear();

src/Restate.Sdk/Internal/Journal/InvocationJournal.cs

@@ -7,6 +7,7 @@ internal sealed class InvocationJournal : IDisposable
     private const int DefaultCapacity = 4;
 
     private JournalEntry[] _entries;
+    private List<byte[]>? _pooledBuffers;
 
     public InvocationJournal()
     {
@@ -28,8 +29,23 @@ public JournalEntry this[int index]
         }
     }
 
+    /// <summary>
+    ///     Tracks a pooled buffer (detached from RawMessage) for batch return on Dispose.
+    /// </summary>
+    public void TrackPooledBuffer(byte[] buffer)
+    {
+        (_pooledBuffers ??= new List<byte[]>(8)).Add(buffer);
+    }
+
     public void Dispose()
     {
+        if (_pooledBuffers is not null)
+        {
+            foreach (var buf in _pooledBuffers)
+                ArrayPool<byte>.Shared.Return(buf);
+            _pooledBuffers = null;
+        }
+
         if (_entries.Length > 0)
         {
             ArrayPool<JournalEntry>.Shared.Return(_entries, true);

src/Restate.Sdk/Internal/Protocol/ProtocolReader.cs

@@ -78,9 +78,18 @@ private bool TryParseMessage(ref ReadOnlySequence<byte> buffer, out RawMessage m
             if (buffer.Length < MessageHeader.Size)
                 return false;
 
-            Span<byte> headerBytes = stackalloc byte[MessageHeader.Size];
-            buffer.Slice(0, MessageHeader.Size).CopyTo(headerBytes);
-            _pendingHeader = MessageHeader.Read(headerBytes);
+            // Fast path: single-segment buffer (common case with Kestrel)
+            if (buffer.FirstSpan.Length >= MessageHeader.Size)
+            {
+                _pendingHeader = MessageHeader.Read(buffer.FirstSpan);
+            }
+            else
+            {
+                Span<byte> headerBytes = stackalloc byte[MessageHeader.Size];
+                buffer.Slice(0, MessageHeader.Size).CopyTo(headerBytes);
+                _pendingHeader = MessageHeader.Read(headerBytes);
+            }
+
             buffer = buffer.Slice(MessageHeader.Size);
             _state = DecoderState.WaitingPayload;
         }
@@ -99,7 +108,12 @@ private bool TryParseMessage(ref ReadOnlySequence<byte> buffer, out RawMessage m
 
             var payloadSlice = buffer.Slice(0, _pendingHeader.Length);
             var rented = ArrayPool<byte>.Shared.Rent((int)_pendingHeader.Length);
-            payloadSlice.CopyTo(rented);
+
+            // Fast path: single-segment avoids ReadOnlySequence.CopyTo overhead
+            if (payloadSlice.IsSingleSegment)
+                payloadSlice.FirstSpan.CopyTo(rented);
+            else
+                payloadSlice.CopyTo(rented);
 
             message = RawMessage.Create(_pendingHeader, rented, (int)_pendingHeader.Length);
             buffer = buffer.Slice(_pendingHeader.Length);

src/Restate.Sdk/Internal/Protocol/RawMessage.cs

@@ -35,6 +35,20 @@ public static RawMessage Create(MessageHeader header, byte[] rentedBuffer, int l
         return new RawMessage(header, rentedBuffer, length);
     }
 
+    /// <summary>
+    ///     Transfers ownership of the pooled payload buffer to the caller.
+    ///     After this call, Dispose() becomes a no-op — the caller is responsible
+    ///     for returning the buffer to ArrayPool when done.
+    /// </summary>
+    public (byte[] Buffer, ReadOnlyMemory<byte> Memory) DetachPayload()
+    {
+        var buf = _rentedBuffer!;
+        var mem = buf.AsMemory(0, _payloadLength);
+        _rentedBuffer = null;
+        _payloadLength = 0;
+        return (buf, mem);
+    }
+
     public void Dispose()
     {
         if (_rentedBuffer is not null)