feat: add SiteStreamGrpcServer with Channel<T> bridge and stream limits

- Define ISiteStreamSubscriber interface for decoupling from SiteRuntime
- Implement SiteStreamGrpcServer (inherits SiteStreamServiceBase) with:
  - Readiness gate (SetReady)
  - Max concurrent stream enforcement
  - Duplicate correlationId replacement (cancels previous stream)
  - StreamRelayActor creation per subscription
  - Bounded Channel<SiteStreamEvent> bridge (1000 capacity, drop-oldest)
  - Clean teardown: unsubscribe, stop actor, remove tracking entry
- Identity-safe cleanup using ConcurrentDictionary.TryRemove(KeyValuePair)
  to prevent replacement streams from being removed by predecessor cleanup
- 7 unit tests covering reject-not-ready, max-streams, duplicate cancel,
  cleanup-on-cancel, subscribe/remove lifecycle, event forwarding

src/ScadaLink.Communication/Grpc/ISiteStreamSubscriber.cs

@@ -0,0 +1,22 @@
+using Akka.Actor;
+
+namespace ScadaLink.Communication.Grpc;
+
+/// <summary>
+/// Abstraction over the site-side stream subscription mechanism.
+/// SiteStreamManager in the SiteRuntime project implements this interface;
+/// the gRPC server depends on it without referencing SiteRuntime directly.
+/// </summary>
+public interface ISiteStreamSubscriber
+{
+    /// <summary>
+    /// Subscribes an actor to receive filtered stream events for a specific instance.
+    /// </summary>
+    /// <returns>A subscription ID that can be used for unsubscription.</returns>
+    string Subscribe(string instanceName, IActorRef subscriber);
+
+    /// <summary>
+    /// Removes all subscriptions for the given actor.
+    /// </summary>
+    void RemoveSubscriber(IActorRef subscriber);
+}

src/ScadaLink.Communication/Grpc/SiteStreamGrpcServer.cs

@@ -0,0 +1,116 @@
+using System.Collections.Concurrent;
+using System.Threading.Channels;
+using Akka.Actor;
+using Grpc.Core;
+using Microsoft.Extensions.Logging;
+using GrpcStatus = Grpc.Core.Status;
+
+namespace ScadaLink.Communication.Grpc;
+
+/// <summary>
+/// gRPC service that accepts instance stream subscriptions from central nodes.
+/// Creates a StreamRelayActor per subscription to bridge Akka domain events
+/// through a Channel&lt;T&gt; to the gRPC response stream.
+/// </summary>
+public class SiteStreamGrpcServer : SiteStreamService.SiteStreamServiceBase
+{
+    private readonly ISiteStreamSubscriber _streamSubscriber;
+    private readonly ActorSystem _actorSystem;
+    private readonly ILogger<SiteStreamGrpcServer> _logger;
+    private readonly ConcurrentDictionary<string, StreamEntry> _activeStreams = new();
+    private readonly int _maxConcurrentStreams;
+    private volatile bool _ready;
+    private long _actorCounter;
+
+    public SiteStreamGrpcServer(
+        ISiteStreamSubscriber streamSubscriber,
+        ActorSystem actorSystem,
+        ILogger<SiteStreamGrpcServer> logger,
+        int maxConcurrentStreams = 100)
+    {
+        _streamSubscriber = streamSubscriber;
+        _actorSystem = actorSystem;
+        _logger = logger;
+        _maxConcurrentStreams = maxConcurrentStreams;
+    }
+
+    /// <summary>
+    /// Marks the server as ready to accept subscriptions.
+    /// Called after the site runtime is fully initialized.
+    /// </summary>
+    public void SetReady() => _ready = true;
+
+    /// <summary>
+    /// Number of currently active streaming subscriptions. Exposed for diagnostics.
+    /// </summary>
+    public int ActiveStreamCount => _activeStreams.Count;
+
+    public override async Task SubscribeInstance(
+        InstanceStreamRequest request,
+        IServerStreamWriter<SiteStreamEvent> responseStream,
+        ServerCallContext context)
+    {
+        if (!_ready)
+            throw new RpcException(new GrpcStatus(StatusCode.Unavailable, "Server not ready"));
+
+        // Duplicate prevention -- cancel existing stream for this correlationId
+        if (_activeStreams.TryRemove(request.CorrelationId, out var existingEntry))
+        {
+            existingEntry.Cts.Cancel();
+            existingEntry.Cts.Dispose();
+        }
+
+        // Check max concurrent streams after duplicate removal
+        if (_activeStreams.Count >= _maxConcurrentStreams)
+            throw new RpcException(new GrpcStatus(StatusCode.ResourceExhausted, "Max concurrent streams reached"));
+
+        using var streamCts = CancellationTokenSource.CreateLinkedTokenSource(context.CancellationToken);
+        var entry = new StreamEntry(streamCts);
+        _activeStreams[request.CorrelationId] = entry;
+
+        var channel = Channel.CreateBounded<SiteStreamEvent>(
+            new BoundedChannelOptions(1000) { FullMode = BoundedChannelFullMode.DropOldest });
+
+        var actorSeq = Interlocked.Increment(ref _actorCounter);
+        var relayActor = _actorSystem.ActorOf(
+            Props.Create(typeof(Actors.StreamRelayActor), request.CorrelationId, channel.Writer),
+            $"stream-relay-{request.CorrelationId}-{actorSeq}");
+
+        var subscriptionId = _streamSubscriber.Subscribe(request.InstanceUniqueName, relayActor);
+
+        _logger.LogInformation(
+            "Stream {CorrelationId} started for {Instance} (subscription {SubscriptionId})",
+            request.CorrelationId, request.InstanceUniqueName, subscriptionId);
+
+        try
+        {
+            await foreach (var evt in channel.Reader.ReadAllAsync(streamCts.Token))
+            {
+                await responseStream.WriteAsync(evt, streamCts.Token);
+            }
+        }
+        catch (OperationCanceledException)
+        {
+            // Normal cancellation (client disconnect or duplicate replacement)
+        }
+        finally
+        {
+            _streamSubscriber.RemoveSubscriber(relayActor);
+            _actorSystem.Stop(relayActor);
+            channel.Writer.TryComplete();
+
+            // Only remove our own entry -- a replacement stream may have already taken the slot
+            _activeStreams.TryRemove(
+                new KeyValuePair<string, StreamEntry>(request.CorrelationId, entry));
+
+            _logger.LogInformation(
+                "Stream {CorrelationId} for {Instance} ended",
+                request.CorrelationId, request.InstanceUniqueName);
+        }
+    }
+
+    /// <summary>
+    /// Tracks a single active stream so cleanup only removes its own entry.
+    /// </summary>
+    private sealed record StreamEntry(CancellationTokenSource Cts);
+}