feat(adapters): align channel adapter with RFC 1

Author: Garfield550

README.md

@@ -206,7 +206,11 @@ usable as an `IEventContext`. The v1 channel adapter is in-process and
 object-only; it forwards existing typed envelopes through
 `System.Threading.Channels` and does not serialize payloads. Default
 `ChannelPipe` channels are unbounded and intended for local composition, tests,
-and same-process boundaries, not as a throughput or backpressure policy.
+and same-process boundaries, not as a throughput or backpressure policy. Both
+`Eventa` and `Eventa.Adapters` enable `IsAotCompatible=true`; the current
+Release builds run cleanly under the trim and Native AOT analyzers, and the
+channel adapter keeps its transport path free of reflection, dynamic dispatch,
+and runtime generic construction.
 
 ## Project Layout
 

src/Eventa.Adapters/Channels/ChannelAdapter.cs

@@ -25,10 +25,28 @@ public void OnSent(string eventId, object? envelope, object? options = null)
                 $"Event '{eventId}' was sent with an envelope that does not implement {nameof(IEventEnvelope)}.");
         }
 
-        if (!outbound.TryWrite(new ChannelMessage(eventEnvelope, options)))
+        var message = new ChannelMessage(eventEnvelope, options);
+        if (outbound.TryWrite(message)) return;
+
+        // Keep Emit synchronous: probe terminal state vs. transient pressure without waiting.
+        var waitToWrite = outbound.WaitToWriteAsync();
+        if (!waitToWrite.IsCompleted)
         {
-            throw new ChannelClosedException("Channel endpoint closed.");
+            throw new InvalidOperationException("Outbound channel could not accept the message immediately.");
         }
+
+        // WaitToWriteAsync(true) only reports a writable window; another writer can still win
+        // that race before we claim the slot, so we need one more non-blocking write attempt.
+        if (waitToWrite.IsCompletedSuccessfully && waitToWrite.Result && outbound.TryWrite(message)) return;
+
+        if (waitToWrite.IsCompletedSuccessfully && waitToWrite.Result)
+        {
+            throw new InvalidOperationException("Outbound channel could not accept the message immediately.");
+        }
+
+        // A synchronously completed false/faulted wait means the writer is terminal. Use WriteAsync
+        // here so completed/faulted channels surface their original exception shape unchanged.
+        outbound.WriteAsync(message).AsTask().GetAwaiter().GetResult();
     }
 
     /// <inheritdoc />

src/Eventa.Adapters/Channels/ChannelEndpoint.cs

@@ -126,6 +126,8 @@ public void Dispose()
     /// <returns>A task that completes when the inbound channel closes or the endpoint terminates.</returns>
     private async Task RunInboundPumpAsync()
     {
+        var completeOutbound = _options.CompleteOutboundOnDispose;
+
         try
         {
             await foreach (var message in _inbound.ReadAllAsync(_disposeCancellation.Token).ConfigureAwait(false))
@@ -138,15 +140,12 @@ private async Task RunInboundPumpAsync()
                 _context.Receive(message.Envelope, message.Options);
             }
 
-            Terminate(
-                new ChannelClosedException("Channel closed."),
-                completeOutbound: true,
-                cancelInbound: false);
+            Terminate(new ChannelClosedException("Channel closed."), completeOutbound, cancelInbound: false);
         }
         catch (OperationCanceledException) when (Volatile.Read(ref _terminalError) is not null) { }
         catch (Exception error)
         {
-            Terminate(error, completeOutbound: true, cancelInbound: false, outboundError: error);
+            Terminate(error, completeOutbound, cancelInbound: false, outboundError: error);
         }
         finally
         {
@@ -180,7 +179,13 @@ private void Terminate(
 
         if (cancelInbound)
         {
-            _disposeCancellation.Cancel();
+            try
+            {
+                // The inbound pump disposes this CTS in its finally block, so a later local Dispose
+                // can race with that cleanup after terminal ownership has already been decided.
+                _disposeCancellation.Cancel();
+            }
+            catch (ObjectDisposedException) { }
         }
 
         _context.NotifyTransportFatal(error);

src/Eventa.Adapters/Channels/ChannelMessages.cs

@@ -5,11 +5,9 @@ namespace Eventa.Adapters.Channels;
 /// <summary>
 /// Carries one Eventa envelope and optional adapter metadata across an in-process channel.
 /// </summary>
-/// <param name="Envelope">The already-created Eventa envelope, or <see langword="null"/> for a malformed message.</param>
+/// <param name="Envelope">The already-created Eventa envelope.</param>
 /// <param name="Options">Optional adapter metadata associated with the envelope.</param>
-public sealed record ChannelMessage(
-    IEventEnvelope? Envelope,
-    object? Options = null);
+public sealed record ChannelMessage(IEventEnvelope Envelope, object? Options = null);
 
 /// <summary>
 /// Payload emitted when a channel endpoint observes terminal transport closure.

src/Eventa/Support/AsyncSignalQueue.cs

@@ -15,7 +15,7 @@ internal sealed class AsyncSignalQueue<T>
     {
         SingleReader = false,
         SingleWriter = false,
-        AllowSynchronousContinuations = false,
+        AllowSynchronousContinuations = true,
     };
 
     private readonly Channel<T> _channel = Channel.CreateUnbounded<T>(ChannelOptions);