feat(statemachine): Http10ClientStateMachine defers encode until body bytes delivered

Implements deferred encode pattern: OnRequest with body stores the request and
sets _outboundBodyPending; OnBodyMessage accumulates the chunk then calls
EncodeDeferred on OutboundBodyComplete to emit TransportData with Content-Length.

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

Author: st0o0

src/TurboHTTP.Tests/Http10/Http10ClientStateMachineSpec.cs

@@ -1,5 +1,8 @@
 using System.Net;
+using System.Text;
+using Akka.Actor;
 using Servus.Akka.Transport;
+using TurboHTTP.Protocol;
 using TurboHTTP.Protocol.Syntax.Http10;
 using TurboHTTP.Protocol.Syntax.Http10.Client;
 using TurboHTTP.Tests.Shared;
@@ -158,4 +161,62 @@ public void Cleanup_should_clear_in_flight_request()
 
         Assert.False(sm.HasInFlightRequest);
     }
+
+    [Fact(Timeout = 5000)]
+    [Trait("RFC", "RFC1945-5")]
+    public async Task OnRequest_with_body_should_emit_transport_data_after_body_chunk()
+    {
+        var system = ActorSystem.Create("sm-test");
+        try
+        {
+            var inbox = Inbox.Create(system);
+            var ops = new FakeOps { StageActor = inbox.Receiver };
+            var sm = new Http10ClientStateMachine(ops, MakeConfig());
+            sm.PreStart();
+
+            var request = new HttpRequestMessage(HttpMethod.Post, "http://example.com/")
+            {
+                Content = new ByteArrayContent(Encoding.UTF8.GetBytes("hello"))
+            };
+            sm.OnRequest(request);
+
+            // No TransportData yet (deferred)
+            Assert.DoesNotContain(ops.Outbound, o => o is TransportData);
+
+            // Receive the OutboundBodyChunk and feed it back
+            var msg = await Task.Run(() => inbox.Receive(TimeSpan.FromSeconds(3)));
+            var chunk = Assert.IsType<OutboundBodyChunk>(msg);
+            sm.OnBodyMessage(chunk);
+
+            var msg2 = await Task.Run(() => inbox.Receive(TimeSpan.FromSeconds(3)));
+            sm.OnBodyMessage(msg2); // OutboundBodyComplete
+
+            // Now TransportData should exist
+            Assert.Contains(ops.Outbound, o => o is TransportData);
+            var td = ops.Outbound.OfType<TransportData>().First();
+            var text = Encoding.ASCII.GetString(td.Buffer.Memory.Span[..td.Buffer.Length]);
+            Assert.Contains("Content-Length: 5", text);
+            Assert.Contains("hello", text);
+        }
+        finally
+        {
+            system.Dispose();
+        }
+    }
+
+    [Fact(Timeout = 5000)]
+    [Trait("RFC", "RFC1945-5")]
+    public void OnRequest_with_body_should_block_CanAcceptRequest_until_body_complete()
+    {
+        var ops = new FakeOps();
+        var sm = new Http10ClientStateMachine(ops, MakeConfig());
+
+        var request = new HttpRequestMessage(HttpMethod.Post, "http://example.com/")
+        {
+            Content = new ByteArrayContent(Encoding.UTF8.GetBytes("hello"))
+        };
+        sm.OnRequest(request);
+
+        Assert.False(sm.CanAcceptRequest);
+    }
 }

src/TurboHTTP/Protocol/Syntax/Http10/Client/Http10ClientStateMachine.cs

@@ -1,3 +1,4 @@
+using System.Buffers;
 using Servus.Akka.Transport;
 using TurboHTTP.Internal;
 using TurboHTTP.Protocol.Syntax.Http10.Options;
@@ -21,8 +22,12 @@ internal sealed class Http10ClientStateMachine : IHttpStateMachine
     private int _reconnectAttempts;
     private RequestBodyHandle? _responseBodyHandle;
     private bool _lastRequestWasHead;
+    private bool _outboundBodyPending;
+    private HttpRequestMessage? _deferredRequest;
+    private IMemoryOwner<byte>? _deferredBodyOwner;
+    private int _deferredBodyLength;
 
-    public bool CanAcceptRequest => _inFlightRequest is null && !IsReconnecting;
+    public bool CanAcceptRequest => _inFlightRequest is null && !IsReconnecting && !_outboundBodyPending;
 
     public bool HasInFlightRequest => _inFlightRequest is not null;
 
@@ -138,14 +143,68 @@ public void OnTimerFired(string name)
     {
     }
 
-    public void OnBodyMessage(object msg) { }
+    public void OnBodyMessage(object msg)
+    {
+        switch (msg)
+        {
+            case OutboundBodyChunk chunk when _deferredRequest is not null:
+                _deferredBodyOwner?.Dispose();
+                _deferredBodyOwner = chunk.Owner;
+                _deferredBodyLength = chunk.Length;
+                break;
+
+            case OutboundBodyComplete when _deferredRequest is not null && _deferredBodyOwner is not null:
+                TransportBuffer? item = null;
+                try
+                {
+                    var body = _deferredBodyOwner.Memory.Span[.._deferredBodyLength];
+                    var bufferSize = Math.Min(_minBufferSize + _deferredBodyLength, _maxBufferSize);
+                    item = TransportBuffer.Rent(bufferSize);
+                    var written = _encoder.EncodeDeferred(item.FullMemory.Span, _deferredRequest, body);
+                    item.Length = written;
+                    _ops.OnOutbound(new TransportData(item));
+                }
+                catch (Exception ex)
+                {
+                    item?.Dispose();
+                    _deferredRequest.Fail(new HttpRequestException("Failed to encode HTTP/1.0 request body.", ex));
+                }
+                finally
+                {
+                    _deferredBodyOwner.Dispose();
+                    _deferredBodyOwner = null;
+                    _deferredRequest = null;
+                    _outboundBodyPending = false;
+                }
+                break;
+
+            case OutboundBodyComplete:
+                _outboundBodyPending = false;
+                break;
+
+            case OutboundBodyFailed failed:
+                _deferredBodyOwner?.Dispose();
+                _deferredBodyOwner = null;
+                _outboundBodyPending = false;
+                if (_deferredRequest is not null)
+                {
+                    _deferredRequest.Fail(new HttpRequestException("Failed to read HTTP/1.0 request body.", failed.Reason));
+                    _deferredRequest = null;
+                }
+                break;
+        }
+    }
 
     public void Cleanup()
     {
         _inFlightRequest = null;
         _responseBodyHandle?.Abort(new OperationCanceledException());
         _responseBodyHandle?.Dispose();
         _responseBodyHandle = null;
+        _outboundBodyPending = false;
+        _deferredBodyOwner?.Dispose();
+        _deferredBodyOwner = null;
+        _deferredRequest = null;
         _decoder.Reset();
     }
 
@@ -173,9 +232,19 @@ private void EncodeRequest(HttpRequestMessage request)
             var span = item.FullMemory.Span;
 
             var written = _encoder.Encode(span, request, _ops.StageActor);
-            item.Length = written;
-
-            _ops.OnOutbound(new TransportData(item));
+            if (written > 0)
+            {
+                item.Length = written;
+                _ops.OnOutbound(new TransportData(item));
+            }
+            else
+            {
+                // Deferred — HTTP/1.0 with body; waiting for OutboundBodyChunk + OutboundBodyComplete
+                item.Dispose();
+                item = null;
+                _deferredRequest = request;
+                _outboundBodyPending = true;
+            }
         }
         catch (Exception ex)
         {