Description: An unbounded Channel is used for _pendingEvents and writes ignore the TryWrite return
value, which can allow uncontrolled queue growth (memory exhaustion) or silent event
dropping under stress, creating a realistic denial-of-service vector if a remote endpoint
can generate events faster than they are processed.
Broker.cs [40-295]

private readonly Channel<(string Method, EventArgs Params)> _pendingEvents = Channel.CreateUnbounded<(string Method, EventArgs Params)>(new(){ SingleReader = true, SingleWriter = true });
private readonly Dictionary<string, JsonTypeInfo> _eventTypesMap = [];

private readonly ConcurrentDictionary<string, List<EventHandler>> _eventHandlers = new();

private long _currentCommandId;

private static readonly TaskFactory _myTaskFactory = new(CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskContinuationOptions.None, TaskScheduler.Default);

private Task? _receivingMessageTask;
private Task? _eventEmitterTask;
private CancellationTokenSource? _receiveMessagesCancellationTokenSource;

internal Broker(BiDi bidi, Uri url)
{
    _bidi = bidi;
    _transport = new WebSocketTransport(url);
}

public async Task ConnectAsync(CancellationToken cancellationToken)
{


 ... (clipped 235 lines)

• Create ticket/issue

Follow the guide to enable codebase context checks.

Objective: To create a detailed and reliable record of critical system actions for security analysis
and compliance.

Status: Passed

Learn more about managing compliance generic rules or creating your own custom rules

Objective: Ensure all identifiers clearly express their purpose and intent, making code
self-documenting

Status: Passed

Learn more about managing compliance generic rules or creating your own custom rules

Objective: To prevent the leakage of sensitive system information through error messages while
providing sufficient detail for internal debugging.

Status: Passed

Learn more about managing compliance generic rules or creating your own custom rules

Objective: Ensure all data inputs are validated, sanitized, and handled securely to prevent
vulnerabilities

Status: Passed

Learn more about managing compliance generic rules or creating your own custom rules

Objective: Ensure comprehensive error handling that provides meaningful context and graceful
degradation

Status:
Dropped event on write: The result of _pendingEvents.Writer.TryWrite(messageEvent) is ignored, so a failed write
can silently drop events without fallback handling or logging.

    var messageEvent = (method, eventArgs);
    _pendingEvents.Writer.TryWrite(messageEvent);
}

Learn more about managing compliance generic rules or creating your own custom rules

Objective: To ensure logs are useful for debugging and auditing without exposing sensitive
information like PII, PHI, or cardholder data.

Status:
Exception details logged: The error log interpolates the full exception object ({ex}), which may include stack
traces and sensitive runtime data and is not structured for safe auditing.

catch (Exception ex)
{
    if (_logger.IsEnabled(LogEventLevel.Error))
    {
        _logger.Error($"Unhandled error processing BiDi event handler: {ex}");
    }

Learn more about managing compliance generic rules or creating your own custom rules

Check the return value of _pendingEvents.Writer.TryWrite and throw an
ObjectDisposedException if it returns false to avoid silently dropping events
when the broker is being disposed.

dotnet/src/webdriver/BiDi/Broker.cs [294]

-_pendingEvents.Writer.TryWrite(messageEvent);
+if (!_pendingEvents.Writer.TryWrite(messageEvent))
+{
+    throw new ObjectDisposedException(nameof(Broker), "Cannot process event as the broker is being disposed.");
+}

• Apply / Chat

Guard DisposeAsync() so it can be safely called multiple times (and from
multiple threads) without Complete() throwing or disposing resources twice.

dotnet/src/webdriver/BiDi/Broker.cs [183-197]

+private int _disposed;
+
 public async ValueTask DisposeAsync()
 {
-    _pendingEvents.Writer.Complete();
+    if (Interlocked.Exchange(ref _disposed, 1) == 1)
+    {
+        return;
+    }
+
+    _pendingEvents.Writer.TryComplete();
 
     _receiveMessagesCancellationTokenSource?.Cancel();
 
     if (_eventEmitterTask is not null)
     {
         await _eventEmitterTask.ConfigureAwait(false);
     }
 
     _transport.Dispose();
 
     GC.SuppressFinalize(this);
 }

• Apply / Chat

-    private readonly Channel<(string Method, EventArgs Params)> _pendingEvents = Channel.CreateUnbounded<(string Method, EventArgs Params)>(new(){ SingleReader = true, SingleWriter = true });
+    private readonly Channel<(string Method, EventArgs Params)> _pendingEvents = Channel.CreateUnbounded<(string Method, EventArgs Params)>(new()
+    {
+        SingleReader = true,
+        SingleWriter = true
+    });

Improve readability by using an explicit UnboundedChannelOptions object when
creating the Channel.

dotnet/src/webdriver/BiDi/Broker.cs [40]

-private readonly Channel<(string Method, EventArgs Params)> _pendingEvents = Channel.CreateUnbounded<(string Method, EventArgs Params)>(new(){ SingleReader = true, SingleWriter = true });
+private readonly Channel<(string Method, EventArgs Params)> _pendingEvents =
+    Channel.CreateUnbounded<(string Method, EventArgs Params)>(new UnboundedChannelOptions
+    {
+        SingleReader = true,
+        SingleWriter = true
+    });

[Suggestion processed]