feat(#535): snapshot sources[] node with framesIngested/droppedFrames (slice 0)

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: iamfatness

native/src/core/MediaCore.cpp

@@ -994,6 +994,28 @@ rpc::Json MediaCore::sessionState() const {
                                    {"showMeters", multiviewShowMeters_},
                                    {"showClock", multiviewShowClock_},
                                });
+  // Per-source bus health (#535 slice 0, Task 4): present even when empty —
+  // the multiviewer-node rule, so the empty (no-source) state stays
+  // observable rather than the node vanishing.
+  {
+    rpc::Json::Array sourcesArr;
+    if (sourceBus_) {
+      const int64_t nowNs = std::chrono::duration_cast<std::chrono::nanoseconds>(
+          std::chrono::steady_clock::now().time_since_epoch()).count();
+      for (const auto& s : sourceBus_->snapshot(nowNs)) {
+        sourcesArr.push_back(rpc::Json::Object{
+            {"sourceId", s.descriptor.sourceId},
+            {"kind", s.descriptor.kind},
+            {"width", static_cast<int>(s.descriptor.width)},
+            {"height", static_cast<int>(s.descriptor.height)},
+            {"framesIngested", static_cast<double>(s.counters.framesIngested)},
+            {"droppedFrames", static_cast<double>(s.counters.droppedFrames)},
+            {"health", sourceHealthName(s.health)},
+        });
+      }
+    }
+    state.emplace("sources", rpc::Json{sourcesArr});
+  }
   const auto recording = recordingState(session);
   if (!recording.isNull()) {
     state.emplace("recording", recording);

native/src/core/SourceBus.h

@@ -12,6 +12,17 @@ namespace corevideo::core {
 
 enum class SourceHealth { Producing, Warming, Stalled, Failed, Idle };
 
+inline const char* sourceHealthName(SourceHealth health) {
+  switch (health) {
+    case SourceHealth::Producing: return "producing";
+    case SourceHealth::Warming: return "warming";
+    case SourceHealth::Stalled: return "stalled";
+    case SourceHealth::Failed: return "failed";
+    case SourceHealth::Idle: return "idle";
+  }
+  return "idle";
+}
+
 struct SourceDescriptor {
   std::string sourceId;   // canonical scheme:id == VideoFrame::participantId
   std::string kind;       // "zoom" | "capture" | "media" | "composed" | "test"

native/tests/SourceBusTest.cpp

@@ -195,3 +195,32 @@ TEST(SourceBusMediaCore, ATestPatternBusSourceCompositesIntoProgram) {
                                 static_cast<uint32_t>(px[c + 0]);
   EXPECT_NE(centerPixel, corevideo::compositor::colorFromParticipantId("test:pattern"));
 }
+
+// --- Task 4: sessionState() sources[] node ---
+
+TEST(SourceBusSnapshot, SourcesNodeCarriesPerSourceCounters) {
+  corevideo::core::MediaCore core(corevideo::modules::createStubModules());
+  core.addSourceForTest(std::make_shared<corevideo::core::TestPatternSource>("test:pattern"));
+
+  for (int i = 0; i < 3; ++i) {
+    core.renderDisplayTick();
+  }
+
+  const auto state = core.sessionState();
+  const auto* sources = state.get("sources");
+  ASSERT_NE(sources, nullptr);
+  const auto& arr = sources->asArray();
+  ASSERT_EQ(arr.size(), 1u);
+  EXPECT_EQ(arr.front().getString("sourceId"), "test:pattern");
+  EXPECT_GE(arr.front().get("framesIngested")->asNumber(), 1.0);
+  EXPECT_EQ(arr.front().get("droppedFrames")->asNumber(), 0.0);
+}
+
+TEST(SourceBusSnapshot, AFreshMediaCoreWithNoSourceStillEmitsAnEmptySourcesArray) {
+  corevideo::core::MediaCore core(corevideo::modules::createStubModules());
+
+  const auto state = core.sessionState();
+  const auto* sources = state.get("sources");
+  ASSERT_NE(sources, nullptr);
+  EXPECT_TRUE(sources->asArray().empty());
+}