feat(phase-16.3): light up anonId unique-listener layer

Mint a first-party localStorage anonId, thread it onto play/share beacons,
persist it via EventController, and add all-time distinct-listener counts
(site/track/release). Storage columns + indexes already existed from 16.1.

DeepDrftTests/AnonIdPayloadTests.cs

@@ -0,0 +1,147 @@
+using System.Text.Json;
+using DeepDrftModels.Enums;
+using DeepDrftPublic.Client.Services;
+using Microsoft.AspNetCore.Components;
+using Microsoft.JSInterop;
+
+namespace DeepDrftTests;
+
+/// <summary>
+/// Tests that the Phase 16 wave-16.3 anon id is threaded onto the beacon payloads emitted by
+/// <see cref="BeaconPlayEventSink"/> and <see cref="ShareTracker"/>, and omitted when the provider has
+/// no token. Both sinks serialize internally and dispatch through <c>BeaconInterop</c> → the
+/// <c>DeepDrftBeacon.send(url, json)</c> JS call, so the assertions capture that JSON string off a fake
+/// JS runtime and inspect the <c>anonId</c> field — the same bytes the browser would POST.
+/// </summary>
+[TestFixture]
+public class AnonIdPayloadTests
+{
+    // Captures the JSON body of the most recent DeepDrftBeacon.send(url, json) invocation. The beacon is
+    // fire-and-forget (returns bool); other interop calls (unload registration) are tolerated and ignored.
+    private sealed class CapturingJsRuntime : IJSRuntime
+    {
+        public string? LastJson { get; private set; }
+
+        public ValueTask<TValue> InvokeAsync<TValue>(string identifier, object?[]? args)
+        {
+            if (identifier == "DeepDrftBeacon.send" && args is { Length: 2 } && args[1] is string json)
+                LastJson = json;
+            return ValueTask.FromResult<TValue>(default!);
+        }
+
+        public ValueTask<TValue> InvokeAsync<TValue>(string identifier, CancellationToken cancellationToken, object?[]? args)
+            => InvokeAsync<TValue>(identifier, args);
+    }
+
+    private sealed class StubAnonIdProvider : IAnonIdProvider
+    {
+        public StubAnonIdProvider(string? current) => Current = current;
+        public string? Current { get; }
+        public ValueTask EnsureLoadedAsync() => ValueTask.CompletedTask;
+    }
+
+    private sealed class TestNavigationManager : NavigationManager
+    {
+        public TestNavigationManager() => Initialize("https://deepdrft.test/", "https://deepdrft.test/");
+        protected override void NavigateToCore(string uri, bool forceLoad) { }
+    }
+
+    // The sinks serialize with default (PascalCase) property names; the API binds case-insensitively, so
+    // the wire field is "AnonId". Match it case-insensitively here so the test asserts the value, not the
+    // casing convention. Returns (present, value) while the document is still alive.
+    private static (bool Present, string? Value) FindAnonId(string json)
+    {
+        using var doc = JsonDocument.Parse(json);
+        foreach (var prop in doc.RootElement.EnumerateObject())
+        {
+            if (string.Equals(prop.Name, "anonId", StringComparison.OrdinalIgnoreCase))
+                return (true, prop.Value.GetString());
+        }
+        return (false, null);
+    }
+
+    private static string? ReadAnonId(string json) => FindAnonId(json).Value;
+
+    private static bool HasAnonIdProperty(string json) => FindAnonId(json).Present;
+
+    // A play emitted while the provider holds a token carries that token in the payload.
+    [Test]
+    public void PlaySink_WithAnonId_IncludesItInPayload()
+    {
+        var js = new CapturingJsRuntime();
+        var sink = new BeaconPlayEventSink(
+            new BeaconInterop(js), new StubAnonIdProvider("listener-42"), new TestNavigationManager());
+
+        sink.EmitPlay("track-key", PlayBucket.Complete);
+
+        Assert.That(js.LastJson, Is.Not.Null);
+        Assert.That(ReadAnonId(js.LastJson!), Is.EqualTo("listener-42"));
+    }
+
+    // A play emitted when the provider has no token (storage unavailable / not warmed) omits anonId
+    // entirely rather than sending anonId:null.
+    [Test]
+    public void PlaySink_WithoutAnonId_OmitsItFromPayload()
+    {
+        var js = new CapturingJsRuntime();
+        var sink = new BeaconPlayEventSink(
+            new BeaconInterop(js), new StubAnonIdProvider(null), new TestNavigationManager());
+
+        sink.EmitPlay("track-key", PlayBucket.Partial);
+
+        Assert.That(js.LastJson, Is.Not.Null);
+        Assert.That(HasAnonIdProperty(js.LastJson!), Is.False, "null anonId is omitted from the wire payload");
+    }
+
+    // A share recorded while the provider holds a token carries it in the payload.
+    [Test]
+    public void ShareTracker_WithAnonId_IncludesItInPayload()
+    {
+        var js = new CapturingJsRuntime();
+        var tracker = new ShareTracker(
+            new BeaconInterop(js), new StubAnonIdProvider("listener-7"), new TestNavigationManager());
+
+        tracker.RecordShare(ShareTargetType.Track, "k", ShareChannel.Link);
+
+        Assert.That(js.LastJson, Is.Not.Null);
+        Assert.That(ReadAnonId(js.LastJson!), Is.EqualTo("listener-7"));
+    }
+
+    // A share recorded with no token omits anonId from the payload.
+    [Test]
+    public void ShareTracker_WithoutAnonId_OmitsItFromPayload()
+    {
+        var js = new CapturingJsRuntime();
+        var tracker = new ShareTracker(
+            new BeaconInterop(js), new StubAnonIdProvider(null), new TestNavigationManager());
+
+        tracker.RecordShare(ShareTargetType.Track, "k", ShareChannel.Link);
+
+        Assert.That(js.LastJson, Is.Not.Null);
+        Assert.That(HasAnonIdProperty(js.LastJson!), Is.False);
+    }
+
+    // A JS runtime that throws on every call — models localStorage interop being unavailable (private
+    // mode, blocked storage, or the module not yet imported during prerender).
+    private sealed class ThrowingJsRuntime : IJSRuntime
+    {
+        public ValueTask<TValue> InvokeAsync<TValue>(string identifier, object?[]? args)
+            => throw new InvalidOperationException("interop unavailable");
+
+        public ValueTask<TValue> InvokeAsync<TValue>(string identifier, CancellationToken cancellationToken, object?[]? args)
+            => throw new InvalidOperationException("interop unavailable");
+    }
+
+    // The real AnonIdProvider degrades to null (no throw) when the localStorage interop is unavailable —
+    // the acceptance-criterion "degrades safely if localStorage is unavailable". EnsureLoadedAsync
+    // swallows the interop failure and leaves Current null.
+    [Test]
+    public async Task AnonIdProvider_WhenInteropUnavailable_DegradesToNullWithoutThrowing()
+    {
+        var provider = new AnonIdProvider(new ThrowingJsRuntime());
+
+        await provider.EnsureLoadedAsync();   // must not throw
+
+        Assert.That(provider.Current, Is.Null);
+    }
+}