DIAGNOSTIC (temporary): verbose logging for macOS sanitized Socket test 8

test_sk1_three_sockets_two_ready_count fails only on macOS+ASan. Add
temporary logging to capture the actual values on the real runner:
 - test: SK1DBG sent/poll1 + a level-triggered re-poll (poll2, no read
   between) to tell an async-delivery snapshot (poll2 sees 2) from a wrong
   result (poll2 still off), plus the fds and each events_ready.
 - SocketPoll: SOCKPOLLDBG raw poll ret + per-fd events/revents.
To be reverted once the CI log pins the failure mode.

Author: brightprogrammer

Source/Misra/Sys/Socket.c

@@ -1033,6 +1033,18 @@ i32 SocketPoll(SocketPollItem *items, u32 count, i32 timeout_ms) {
     }
 #endif
 
+    // --- TEMP DIAGNOSTIC (remove after CI) ---
+    LOG_ERROR("SOCKPOLLDBG count={} timeout={} ret={}", count, timeout_ms, ret);
+    for (u32 di = 0; di < count && di < 8; ++di) {
+        LOG_ERROR(
+            "SOCKPOLLDBG   fd[{}]={} events={x} revents={x}",
+            di,
+            (i64)items[di].fd,
+            (u32)pfds[di].events,
+            (u32)pfds[di].revents
+        );
+    }
+
     if (ret >= 0) {
         for (u32 i = 0; i < count; ++i) {
             u32 ready = 0;

Tests/Std/Socket.c

@@ -387,7 +387,18 @@ bool test_sk1_three_sockets_two_ready_count(void) {
     }
 
     // Make server0 and server2 readable; server1 stays idle.
-    bool sent = SocketSend(&p0.client, "A", 1) == 1 && SocketSend(&p2.client, "C", 1) == 1;
+    i64  s0   = SocketSend(&p0.client, "A", 1);
+    i64  s2   = SocketSend(&p2.client, "C", 1);
+    bool sent = s0 == 1 && s2 == 1;
+    // --- TEMP DIAGNOSTIC (remove after CI) ---
+    WriteFmt(
+        "SK1DBG sent s0={} s2={} fd0={} fd1={} fd2={}\n",
+        s0,
+        s2,
+        (i64)p0.server.fd,
+        (i64)p1.server.fd,
+        (i64)p2.server.fd
+    );
 
     SocketPollItem items[3]   = {0};
     items[0].fd               = p0.server.fd;
@@ -398,6 +409,33 @@ bool test_sk1_three_sockets_two_ready_count(void) {
     items[2].events_requested = SOCKET_POLL_READ;
 
     i32 n = SocketPoll(items, 3, 1000);
+    // --- TEMP DIAGNOSTIC (remove after CI) ---
+    WriteFmt(
+        "SK1DBG poll1 n={} r0={x} r1={x} r2={x}\n",
+        n,
+        items[0].events_ready,
+        items[1].events_ready,
+        items[2].events_ready
+    );
+    // Re-poll the same fds without reading: poll is level-triggered, so a
+    // socket that's genuinely readable stays readable. If poll1 missed one
+    // because its byte was still in flight (async loopback), poll2 now sees
+    // it -> timing snapshot. If poll2 is still wrong -> a real defect.
+    SocketPollItem items2[3]   = {0};
+    items2[0].fd               = p0.server.fd;
+    items2[0].events_requested = SOCKET_POLL_READ;
+    items2[1].fd               = p1.server.fd;
+    items2[1].events_requested = SOCKET_POLL_READ;
+    items2[2].fd               = p2.server.fd;
+    items2[2].events_requested = SOCKET_POLL_READ;
+    i32 n2                     = SocketPoll(items2, 3, 1000);
+    WriteFmt(
+        "SK1DBG poll2 n={} r0={x} r1={x} r2={x}\n",
+        n2,
+        items2[0].events_ready,
+        items2[1].events_ready,
+        items2[2].events_ready
+    );
 
     bool ok = sent && n == 2 && (items[0].events_ready & SOCKET_POLL_READ) != 0 &&
               (items[1].events_ready & SOCKET_POLL_READ) == 0 && (items[2].events_ready & SOCKET_POLL_READ) != 0;