add platform tracking to dashboard

- track soundcloud/bandcamp/spotify/plyr.fm matches separately
- show platform breakdown with color-coded bar charts on dashboard
- fix terminology: turbostream is a stream provider, not a relay

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <[e-mail]>

src/dashboard.zig

···
 const std = @import("std");
-const posix = std.posix;
 const stats = @import("stats.zig");
 const db = @import("db.zig");
-
-const DEFAULT_TURBOSTREAM = "api.graze.social";
 
 fn formatNumber(buf: []u8, n: u64) []const u8 {
     var temp: [32]u8 = undefined;
···
     const lag_ms = s.getPostLagMs();
     const lag_sec = @divTrunc(lag_ms, 1000);
     const status = s.getStatus();
-    const turbostream_host = posix.getenv("TURBOSTREAM_HOST") orelse DEFAULT_TURBOSTREAM;
 
     var buf: std.ArrayList(u8) = .{};
     const w = buf.writer(alloc);
···
         \\    }
         \\    .stat-value { font-size: 18px; color: #fff; }
         \\    .stat-label { font-size: 11px; color: #444; }
-        \\    .criteria {
+        \\    .criteria, .platforms {
         \\      margin-bottom: 1.5rem;
         \\      font-size: 12px;
         \\    }
         \\    .criteria-title { color: #444; margin-bottom: 0.25rem; }
         \\    .criteria-list { color: #666; }
+        \\    .platform-bars { margin-top: 0.5rem; }
+        \\    .platform-row { display: flex; align-items: center; gap: 0.5rem; margin-bottom: 0.3rem; }
+        \\    .platform-name { width: 80px; color: #666; }
+        \\    .bar { flex: 1; height: 8px; background: #1a1a1a; border-radius: 4px; overflow: hidden; }
+        \\    .bar-fill { height: 100%; border-radius: 4px; }
+        \\    .platform-pct { width: 32px; text-align: right; color: #555; font-size: 11px; }
         \\    footer {
         \\      padding-top: 1rem;
         \\      border-top: 1px solid #1a1a1a;
···
         \\      </div>
         \\    </div>
         \\
-        \\    <div class="criteria">
-        \\      <div class="criteria-title">included</div>
-        \\      <div class="criteria-list">soundcloud, bandcamp, spotify, plyr.fm links</div>
+        \\    <div class="platforms">
+        \\      <div class="criteria-title">platforms</div>
+        \\      <div class="platform-bars">
+    );
+
+    // get platform counts
+    const platforms = s.getPlatformCounts();
+    const total = platforms.soundcloud + platforms.bandcamp + platforms.spotify + platforms.plyr;
+
+    if (total > 0) {
+        // calculate percentages
+        const sc_pct = (platforms.soundcloud * 100) / total;
+        const bc_pct = (platforms.bandcamp * 100) / total;
+        const sp_pct = (platforms.spotify * 100) / total;
+        const pl_pct = (platforms.plyr * 100) / total;
+
+        try w.print(
+            \\        <div class="platform-row"><span class="platform-name">soundcloud</span><div class="bar"><div class="bar-fill" style="width:{d}%;background:#ff5500"></div></div><span class="platform-pct">{d}%</span></div>
+            \\        <div class="platform-row"><span class="platform-name">bandcamp</span><div class="bar"><div class="bar-fill" style="width:{d}%;background:#1da0c3"></div></div><span class="platform-pct">{d}%</span></div>
+            \\        <div class="platform-row"><span class="platform-name">spotify</span><div class="bar"><div class="bar-fill" style="width:{d}%;background:#1db954"></div></div><span class="platform-pct">{d}%</span></div>
+            \\        <div class="platform-row"><span class="platform-name">plyr.fm</span><div class="bar"><div class="bar-fill" style="width:{d}%;background:#7c3aed"></div></div><span class="platform-pct">{d}%</span></div>
+        , .{ sc_pct, sc_pct, bc_pct, bc_pct, sp_pct, sp_pct, pl_pct, pl_pct });
+    } else {
+        try w.writeAll(
+            \\        <div class="platform-row"><span class="criteria-list">collecting data...</span></div>
+        );
+    }
+
+    try w.writeAll(
+        \\      </div>
         \\    </div>
         \\
         \\    <div class="criteria">
···
         \\
         \\    <footer>
         \\      <a href="https://tangled.sh/@zzstoatzz.io/music-atmosphere-feed">source</a>
-        \\      <span>relay: <a href="https://
-    );
-    try w.writeAll(turbostream_host);
-    try w.writeAll(
-        \\" target="_blank">
-    );
-    try w.writeAll(turbostream_host);
-    try w.writeAll(
-        \\</a></span>
+        \\      <span>stream: <a href="https://graze.social" target="_blank">turbostream</a></span>
         \\    </footer>
         \\  </div>
         \\

src/filter.zig

···
 const std = @import("std");
 const mem = std.mem;
 const json = std.json;
+const stats = @import("stats.zig");
 
 const Record = json.ObjectMap;
 const Filter = *const fn (Record) ?bool;
···
         if (mem.indexOf(u8, uri, domain) != null) return true;
     }
     return false;
+}
+
+/// detect which platform a URL belongs to
+pub fn detectPlatform(uri: []const u8) ?stats.Platform {
+    if (mem.indexOf(u8, uri, "soundcloud.com") != null or
+        mem.indexOf(u8, uri, "on.soundcloud.com") != null)
+    {
+        return .soundcloud;
+    }
+    if (mem.indexOf(u8, uri, "bandcamp.com") != null) return .bandcamp;
+    if (mem.indexOf(u8, uri, "open.spotify.com") != null or
+        mem.indexOf(u8, uri, "spotify.link") != null)
+    {
+        return .spotify;
+    }
+    if (mem.indexOf(u8, uri, "plyr.fm") != null) return .plyr;
+    return null;
+}
+
+/// detect platform from post record (checks facets and embeds)
+pub fn detectPlatformFromRecord(record: Record) ?stats.Platform {
+    // check facets
+    if (record.get("facets")) |facets_val| {
+        if (facets_val == .array) {
+            for (facets_val.array.items) |facet| {
+                if (facet != .object) continue;
+                const features_val = facet.object.get("features") orelse continue;
+                if (features_val != .array) continue;
+
+                for (features_val.array.items) |feature| {
+                    if (feature != .object) continue;
+                    const uri_val = feature.object.get("uri") orelse continue;
+                    if (uri_val != .string) continue;
+                    if (detectPlatform(uri_val.string)) |p| return p;
+                }
+            }
+        }
+    }
+
+    // check embed
+    if (record.get("embed")) |embed_val| {
+        if (embed_val == .object) {
+            if (embed_val.object.get("external")) |external_val| {
+                if (external_val == .object) {
+                    if (external_val.object.get("uri")) |uri_val| {
+                        if (uri_val == .string) {
+                            if (detectPlatform(uri_val.string)) |p| return p;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    return null;
 }
 
 /// simple text-based check for music links (used for backfill)

src/jetstream.zig

···
         };
 
         stats.get().recordMatch();
+
+        // track platform
+        if (filter.detectPlatformFromRecord(post_record.object)) |platform| {
+            stats.get().recordPlatform(platform);
+        }
+
         std.debug.print("added: {s}\n", .{at_uri.string});
     }
 };

src/stats.zig

···
 
 const STATS_PATH = "/data/stats.json";
 
+pub const Platform = enum { soundcloud, bandcamp, spotify, plyr };
+
 pub const Stats = struct {
     started_at: i64,
     prior_uptime: u64 = 0,
···
     connected_at: Atomic(i64),
     last_post_time_ms: Atomic(i64), // actual post creation time from TID
 
+    // platform counters
+    soundcloud: Atomic(u64),
+    bandcamp: Atomic(u64),
+    spotify: Atomic(u64),
+    plyr: Atomic(u64),
+
     // for lag trend tracking
     prev_lag_ms: Atomic(i64),
 
···
             .last_match_time = Atomic(i64).init(0),
             .connected_at = Atomic(i64).init(0),
             .last_post_time_ms = Atomic(i64).init(0),
+            .soundcloud = Atomic(u64).init(0),
+            .bandcamp = Atomic(u64).init(0),
+            .spotify = Atomic(u64).init(0),
+            .plyr = Atomic(u64).init(0),
             .prev_lag_ms = Atomic(i64).init(0),
         };
         self.load();
···
     pub fn recordMatch(self: *Stats) void {
         _ = self.matches.fetchAdd(1, .monotonic);
         self.last_match_time.store(std.time.milliTimestamp(), .monotonic);
+    }
+
+    pub fn recordPlatform(self: *Stats, platform: Platform) void {
+        switch (platform) {
+            .soundcloud => _ = self.soundcloud.fetchAdd(1, .monotonic),
+            .bandcamp => _ = self.bandcamp.fetchAdd(1, .monotonic),
+            .spotify => _ = self.spotify.fetchAdd(1, .monotonic),
+            .plyr => _ = self.plyr.fetchAdd(1, .monotonic),
+        }
+    }
+
+    pub fn getPlatformCounts(self: *const Stats) struct { soundcloud: u64, bandcamp: u64, spotify: u64, plyr: u64 } {
+        return .{
+            .soundcloud = self.soundcloud.load(.monotonic),
+            .bandcamp = self.bandcamp.load(.monotonic),
+            .spotify = self.spotify.load(.monotonic),
+            .plyr = self.plyr.load(.monotonic),
+        };
     }
 
     pub fn recordConnected(self: *Stats) void {