chore: document and test empty request stream behavior

Author: Garfield550

src/Eventa/EventInvoke.cs

@@ -343,11 +343,16 @@ async Task HandleInvokeAsync(RequestStreamInvocationState<TRequest> state)
             }),
             context.On(sendStreamEndEvent, envelope =>
             {
+                // Keep empty request streams as a supported C# contract even though they
+                // materialize state for unknown invokeIds. This is not current TypeScript parity.
                 var state = GetOrCreateState(envelope.Body.InvokeId);
                 state.Requests.Complete();
             }),
             context.On(sendAbortEvent, envelope =>
             {
+                // Keep pre-first-item aborts as a supported C# contract even though they
+                // can materialize state for unknown invokeIds so the handler still
+                // observes cancellation. This is not current TypeScript parity.
                 var state = GetOrCreateState(envelope.Body.InvokeId);
                 state.Requests.Fault(new OperationCanceledException(state.CancellationSource.Token));
                 state.CancellationSource.Cancel();

src/Eventa/EventStream.cs

@@ -246,11 +246,16 @@ async Task HandleInvokeAsync(RequestStreamInvocationState<TRequest> state)
             }),
             context.On(sendStreamEndEvent, envelope =>
             {
+                // Keep empty request streams as a supported C# contract even though
+                // TypeScript stream.ts ignores sendEventStreamEnd for unknown invokeIds.
                 var state = GetOrCreateState(envelope.Body.InvokeId);
                 state.Requests.Complete();
             }),
             context.On(sendAbortEvent, envelope =>
             {
+                // Keep pre-first-item aborts as a supported C# contract even though they
+                // can materialize state for unknown invokeIds so the handler still
+                // observes cancellation. This is not current TypeScript parity.
                 var state = GetOrCreateState(envelope.Body.InvokeId);
                 state.Requests.Fault(new OperationCanceledException(state.CancellationSource.Token));
                 state.CancellationSource.Cancel();

tests/Eventa.Tests/StreamTests.cs

@@ -401,6 +401,72 @@ public async Task DefineStreamInvoke_SupportsEmptyRequestStreamInput()
         Assert.Equal([0], results);
     }
 
+    [Fact]
+    public async Task DefineStreamInvokeHandler_CompletesEmptyRequestStreamProtocolMessages()
+    {
+        var context = new EventContext();
+        var definition = new InvokeEventDefinition<int, int>("sum-stream-empty-protocol");
+        var invokeId = "invoke-empty";
+        var sendStreamEndEvent = new EventDefinition<StreamEndPayload>(definition.SendStreamEndId);
+        var receiveEvent = new EventDefinition<ReceivePayload<int>>(definition.ReceiveEventId);
+        var receiveErrorEvent = new EventDefinition<ReceiveErrorPayload>(definition.ReceiveErrorId);
+        var receiveStreamEndEvent = new EventDefinition<StreamEndPayload>(definition.ReceiveStreamEndId);
+        var response = new TaskCompletionSource<ReceivePayload<int>>(TaskCreationOptions.RunContinuationsAsynchronously);
+        var streamEnded = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+        var received = new List<int>();
+        var handlerStarts = 0;
+
+        async IAsyncEnumerable<int> Handler(
+            IAsyncEnumerable<int> request,
+            [EnumeratorCancellation] CancellationToken cancellationToken)
+        {
+            Interlocked.Increment(ref handlerStarts);
+
+            await foreach (var value in request.WithCancellation(cancellationToken))
+            {
+                received.Add(value);
+                yield return value;
+            }
+
+            yield return 0;
+        }
+
+        using var _ = context.On(receiveEvent, envelope =>
+        {
+            if (envelope.Body.InvokeId == invokeId)
+            {
+                response.TrySetResult(envelope.Body);
+            }
+        });
+        using var __ = context.On(receiveErrorEvent, envelope =>
+        {
+            if (envelope.Body.InvokeId == invokeId)
+            {
+                response.TrySetException(envelope.Body.Error);
+            }
+        });
+        using var ___ = context.On(receiveStreamEndEvent, envelope =>
+        {
+            if (envelope.Body.InvokeId == invokeId)
+            {
+                streamEnded.TrySetResult(true);
+            }
+        });
+        using var ____ = EventStream.DefineStreamInvokeHandler(
+            context,
+            definition,
+            Handler);
+
+        context.Emit(sendStreamEndEvent, new StreamEndPayload(invokeId));
+
+        var result = await response.Task.WaitAsync(TimeSpan.FromSeconds(5), TestContext.Current.CancellationToken);
+        await streamEnded.Task.WaitAsync(TimeSpan.FromSeconds(5), TestContext.Current.CancellationToken);
+
+        Assert.Equal(1, Volatile.Read(ref handlerStarts));
+        Assert.Empty(received);
+        Assert.Equal(new ReceivePayload<int>(invokeId, 0), result);
+    }
+
     [Fact]
     public async Task DefineStreamInvoke_AbortsRequestStreamAndNotifiesHandler()
     {

…/Eventa.Tests/TypeScriptTestInventory.md ….Tests/docs/typescript-test-inventory.mdtests/Eventa.Tests/TypeScriptTestInventory.md renamed to tests/Eventa.Tests/docs/typescript-test-inventory.md tests/Eventa.Tests/TypeScriptTestInventory.md renamed to tests/Eventa.Tests/docs/typescript-test-inventory.md

@@ -12,8 +12,8 @@ Status labels:
 | Doc section | Status | Current C# target | Covered / deferred details |
 | --- | --- | --- | --- |
 | `context.spec.ts` | `covered` | `EventContextTests.cs` | Covers register+emit, same handler only once, once listeners, `off(event)`, returned disposer, `off(event, handler)`, and returned disposer for a specific listener. |
-| `invoke.spec.ts` | `covered` + `adapted` + `deferred` | `InvokeTests.cs` | Covered: request-response, sync lazy context, request-derived error message, exact error instance propagation, abort/cancel with handler notification, concurrent invokes, same handler once, returned handler removal. Adapted: request-stream input and request-stream abort are currently covered at the protocol/handler layer because C# has no public client invoke overload for request streams. Deferred: async lazy context, undefine handler, batch registration, public client-side request stream invoke parity. |
-| `stream.spec.ts` | `covered` | `StreamTests.cs` | Covers server-streaming, `ToStreamHandler`, concurrent streams, error surfacing, abort stream, cancel stream via async enumerator disposal, abort request stream with paced input, request stream input, `ToStreamHandler` + stream input. |
+| `invoke.spec.ts` | `covered` + `adapted` + `deferred` | `InvokeTests.cs` | Covered: request-response, sync lazy context, request-derived error message, exact error instance propagation, abort/cancel with handler notification, concurrent invokes, same handler once, returned handler removal. Adapted: request-stream input and request-stream abort are currently covered at the protocol/handler layer because C# has no public client invoke overload for request streams. Extra C# contract within that adapted coverage: empty request streams are accepted by materializing handler state on `sendStreamEndEvent`, and pre-first-item abort still notifies the handler; those behaviors are not current TS parity. Deferred: async lazy context, undefine handler, batch registration, public client-side request stream invoke parity. |
+| `stream.spec.ts` | `covered` + `extra` | `StreamTests.cs` | Covers server-streaming, `ToStreamHandler`, concurrent streams, error surfacing, abort stream, cancel stream via async enumerator disposal, abort request stream with paced input, abort request stream before first item, request stream input, `ToStreamHandler` + stream input. Extra C# contract: empty request stream input is intentionally supported even though TS `stream.ts` currently ignores `sendEventStreamEnd` for unknown `invokeId`, and pre-first-item abort still materializes handler state so cancellation is observed; these behaviors are not current TS parity. |
 | `invoke-shared.spec.ts` | `covered` | `EventaTests.cs`, `Primitives/EventDefinitionTests.cs`, `Primitives/InvokeEventDefinitionTests.cs` | Adapted to C# by validating tag-derived event IDs and generated uniqueness instead of TS `invokeType` enum objects. |
 | `invoke-remote-methods.spec.ts` | `deferred` | none | No corresponding C# public API for remote method stubs. |
 | `context-extension-invoke-internal.spec.ts` | `covered` | `InvokeExtensionsTests.cs` | Validates `RegisterAbortEvent` through the public extension surface. |