EventSource

@implements IAsyncDisposable
@inject Bit.Butil.EventSource eventSource

@code {
    private EventSourceHandle? _stream;
    private readonly List<ServerSentEvent> _events = [];

    private async Task Open()
    {
        _stream = await eventSource.Open(
            "/sse/ticks",
            onMessage: e => InvokeAsync(() =>
            {
                // e.EventName is "message" for unnamed events, the server's name otherwise
                // e.Data is always text - deserialize it yourself
                // e.LastEventId is what the browser replays on reconnect
                _events.Insert(0, e);
                StateHasChanged();
            }),
            // Named events never reach the default listener, so anything the server names has to be
            // declared here to be seen at all.
            eventNames: ["heartbeat"],
            onOpen: () => InvokeAsync(StateHasChanged),
            onError: fatal => InvokeAsync(StateHasChanged));
    }

    // Closing is what stops the browser reconnecting: an EventSource that is never closed keeps
    // retrying on the browser's own schedule for as long as the page lives.
    public async ValueTask DisposeAsync()
    {
        if (_stream is not null) await _stream.DisposeAsync();
    }
}

// The other end. Server-sent events are ordinary HTTP with a content type and a wire format - there
// is no protocol upgrade and no library involved.
app.MapGet("/sse/ticks", async (HttpContext context, CancellationToken cancellationToken) =>
{
    context.Response.Headers.ContentType = "text/event-stream";
    context.Response.Headers.CacheControl = "no-cache";
    // Proxies that buffer would defeat the whole point; this is the conventional opt-out.
    context.Response.Headers["X-Accel-Buffering"] = "no";

    // What makes a reconnect resume rather than restart: the browser sends back the last id it saw.
    var next = int.TryParse(context.Request.Headers["Last-Event-ID"], out var lastId) ? lastId + 1 : 1;

    while (cancellationToken.IsCancellationRequested is false)
    {
        // Data is text on the wire; JSON is just the convention for putting structure in it.
        var payload = JsonSerializer.Serialize(new { tick = next });

        await context.Response.WriteAsync($"id: {next}\n", cancellationToken);

        // An event with no name arrives on the default message listener; a named one only reaches a
        // listener that asked for that name.
        if (next % 3 == 0) await context.Response.WriteAsync("event: heartbeat\n", cancellationToken);

        // The blank line is the frame delimiter - without it nothing is ever dispatched.
        await context.Response.WriteAsync($"data: {payload}\n\n", cancellationToken);
        await context.Response.Body.FlushAsync(cancellationToken);

        next++;
        await Task.Delay(TimeSpan.FromSeconds(1), cancellationToken);
    }
});