@scriptc/runtime 0.0.0 → 0.0.2

package/src/scr_loop_epoll.c

@@ -0,0 +1,241 @@
+/* The Linux backend of the platform readiness contract (scr_platform.h):
+ * epoll for fd readiness, one timerfd per armed one-shot timer. This is
+ * the LIVE Linux poller behind scr_net.c and scr_dgram.c (cc.ts links it
+ * alongside scr_loop_kqueue.c whenever those units compile; each TU is
+ * empty off its platform). Child-exit wakeups are NOT here: scr_child.c
+ * keeps its narrow seam inline (kqueue EVFILT_PROC on BSD, pidfd_open +
+ * a dedicated epoll on Linux) because that unit links into every binary
+ * and its plumbing never matched the fd/timer poller shape.
+ *
+ * Design notes:
+ * - Interest is keyed by fd with ONE mask under epoll, so the poller keeps
+ *   a linear fd -> (mask, udata) table and merges read/write interest into
+ *   EPOLL_CTL_MOD. Linear scan is fine at the units' scale (dozens of fds,
+ *   drained in 64-event batches today); swap for a hash if profiles say so.
+ * - EPOLLHUP/EPOLLERR/EPOLLRDHUP report as READABLE (plus WRITABLE when
+ *   write interest is armed): the units learn EOF/errors from read()==0 or
+ *   errno exactly as they do from kqueue's EV_EOF today. Note an fd is in
+ *   the epoll set ONLY while some interest is armed, so a consumer-less
+ *   socket can never busy-report HUP.
+ * - Timers: EVFILT_TIMER has no epoll analogue, so each armed key owns a
+ *   TFD_NONBLOCK timerfd registered EPOLLIN in the same epoll set, tagged
+ *   through the same table (mask=TIMER). Fired timers are disarmed and
+ *   their timerfd closed at delivery (kqueue's EV_ONESHOT semantics).
+ * - Units must scrp_forget a watched fd before close(2) (the contract's
+ *   epoll obligation). As a second line of defense against a missed
+ *   forget followed by fd-number reuse, watch self-heals: a MOD that
+ *   reports ENOENT retries as ADD, an ADD that reports EEXIST retries as
+ *   MOD — the table entry then matches reality again. */
+#if defined(__linux__)
+
+#define _GNU_SOURCE 1
+#include "scr_platform.h"
+
+#include <errno.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/epoll.h>
+#include <sys/timerfd.h>
+#include <unistd.h>
+
+/* ── fd/timer poller ─────────────────────────────────────────────────── */
+
+typedef struct {
+  int fd;          /* watched fd, or the timer's timerfd */
+  unsigned mask;   /* SCRP_READABLE|SCRP_WRITABLE, or SCRP_TIMER */
+  void *udata;     /* delivery tag; for timers: the arm-time udata */
+  void *timer_key; /* timers only: the caller's key */
+} ScrpEntry;
+
+struct ScrPoller {
+  int ep;
+  ScrpEntry *entries;
+  size_t n, cap;
+};
+
+static ScrpEntry *scrp_find_fd(ScrPoller *p, int fd) {
+  for (size_t i = 0; i < p->n; i++)
+    if (p->entries[i].fd == fd) return &p->entries[i];
+  return NULL;
+}
+
+static ScrpEntry *scrp_find_key(ScrPoller *p, void *key) {
+  for (size_t i = 0; i < p->n; i++)
+    if ((p->entries[i].mask & SCRP_TIMER) != 0 && p->entries[i].timer_key == key) return &p->entries[i];
+  return NULL;
+}
+
+static void scrp_remove(ScrPoller *p, ScrpEntry *e) {
+  size_t i = (size_t)(e - p->entries);
+  p->entries[i] = p->entries[p->n - 1];
+  p->n--;
+}
+
+static bool scrp_push(ScrPoller *p, ScrpEntry e) {
+  if (p->n == p->cap) {
+    size_t cap = p->cap == 0 ? 16 : p->cap * 2;
+    ScrpEntry *grown = realloc(p->entries, cap * sizeof *grown);
+    if (grown == NULL) return false;
+    p->entries = grown;
+    p->cap = cap;
+  }
+  p->entries[p->n++] = e;
+  return true;
+}
+
+ScrPoller *scrp_poller_new(void) {
+  ScrPoller *p = calloc(1, sizeof *p);
+  if (p == NULL) return NULL;
+  p->ep = epoll_create1(EPOLL_CLOEXEC);
+  if (p->ep < 0) {
+    free(p);
+    return NULL;
+  }
+  return p;
+}
+
+void scrp_poller_free(ScrPoller *p) {
+  if (p == NULL) return;
+  for (size_t i = 0; i < p->n; i++)
+    if ((p->entries[i].mask & SCRP_TIMER) != 0) close(p->entries[i].fd);
+  close(p->ep);
+  free(p->entries);
+  free(p);
+}
+
+int scrp_poller_fd(const ScrPoller *p) { return p->ep; }
+
+static uint32_t scrp_epoll_mask(unsigned mask) {
+  uint32_t ev = 0;
+  if ((mask & SCRP_READABLE) != 0) ev |= EPOLLIN;
+  if ((mask & SCRP_WRITABLE) != 0) ev |= EPOLLOUT;
+  return ev;
+}
+
+static bool scrp_watch(ScrPoller *p, int fd, void *udata, bool on, unsigned bit) {
+  ScrpEntry *e = scrp_find_fd(p, fd);
+  unsigned mask = e != NULL ? e->mask : 0u;
+  unsigned next = on ? (mask | bit) : (mask & ~bit);
+  if (next == mask && (e == NULL || e->udata == udata)) {
+    if (e != NULL) e->udata = udata;
+    return true;
+  }
+  struct epoll_event ev = {.events = scrp_epoll_mask(next), .data = {.fd = fd}};
+  if (e == NULL) {
+    if (next == 0) return true; /* unwatch of an unwatched fd: no-op */
+    if (!scrp_push(p, (ScrpEntry){fd, next, udata, NULL})) return false;
+    int rc = epoll_ctl(p->ep, EPOLL_CTL_ADD, fd, &ev);
+    if (rc != 0 && errno == EEXIST) rc = epoll_ctl(p->ep, EPOLL_CTL_MOD, fd, &ev);
+    if (rc != 0) {
+      scrp_remove(p, &p->entries[p->n - 1]);
+      return false;
+    }
+    return true;
+  }
+  if (next == 0) {
+    (void)epoll_ctl(p->ep, EPOLL_CTL_DEL, fd, NULL);
+    scrp_remove(p, e);
+    return true;
+  }
+  int rc = epoll_ctl(p->ep, EPOLL_CTL_MOD, fd, &ev);
+  if (rc != 0 && errno == ENOENT) rc = epoll_ctl(p->ep, EPOLL_CTL_ADD, fd, &ev);
+  if (rc != 0) return false;
+  e->mask = next;
+  e->udata = udata; /* last registration wins, both directions */
+  return true;
+}
+
+bool scrp_watch_read(ScrPoller *p, int fd, void *udata, bool on) {
+  return scrp_watch(p, fd, udata, on, SCRP_READABLE);
+}
+
+bool scrp_watch_write(ScrPoller *p, int fd, void *udata, bool on) {
+  return scrp_watch(p, fd, udata, on, SCRP_WRITABLE);
+}
+
+void scrp_forget(ScrPoller *p, int fd) {
+  ScrpEntry *e = scrp_find_fd(p, fd);
+  if (e == NULL) return;
+  (void)epoll_ctl(p->ep, EPOLL_CTL_DEL, fd, NULL);
+  scrp_remove(p, e);
+}
+
+bool scrp_timer_arm(ScrPoller *p, void *key, double ms, void *udata) {
+  if (!(ms >= 0)) ms = 0;
+  ScrpEntry *e = scrp_find_key(p, key);
+  int tfd = e != NULL ? e->fd : timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK | TFD_CLOEXEC);
+  if (tfd < 0) return false;
+  struct itimerspec its;
+  memset(&its, 0, sizeof its);
+  its.it_value.tv_sec = (time_t)(ms / 1000.0);
+  its.it_value.tv_nsec = (long)((ms - (double)its.it_value.tv_sec * 1000.0) * 1e6);
+  if (its.it_value.tv_sec == 0 && its.it_value.tv_nsec == 0) its.it_value.tv_nsec = 1; /* 0 disarms timerfd */
+  if (timerfd_settime(tfd, 0, &its, NULL) != 0) {
+    if (e == NULL) close(tfd);
+    return false;
+  }
+  if (e != NULL) {
+    e->udata = udata;
+    return true; /* re-arm replaces the deadline */
+  }
+  if (!scrp_push(p, (ScrpEntry){tfd, SCRP_TIMER, udata, key})) {
+    close(tfd);
+    return false;
+  }
+  struct epoll_event ev = {.events = EPOLLIN, .data = {.fd = tfd}};
+  if (epoll_ctl(p->ep, EPOLL_CTL_ADD, tfd, &ev) != 0) {
+    scrp_remove(p, &p->entries[p->n - 1]);
+    close(tfd);
+    return false;
+  }
+  return true;
+}
+
+void scrp_timer_cancel(ScrPoller *p, void *key) {
+  ScrpEntry *e = scrp_find_key(p, key);
+  if (e == NULL) return; /* unarmed or already fired: no-op */
+  (void)epoll_ctl(p->ep, EPOLL_CTL_DEL, e->fd, NULL);
+  close(e->fd);
+  scrp_remove(p, e);
+}
+
+int scrp_drain(ScrPoller *p, ScrPollerEvent *out, int max) {
+  if (max <= 0) return 0;
+  struct epoll_event evs[64];
+  int want = max < 64 ? max : 64;
+  int n = epoll_wait(p->ep, evs, want, 0);
+  if (n <= 0) return 0; /* EINTR/none: a spurious pass */
+  int filled = 0;
+  for (int i = 0; i < n; i++) {
+    ScrpEntry *e = scrp_find_fd(p, evs[i].data.fd);
+    if (e == NULL) continue; /* raced with forget */
+    if ((e->mask & SCRP_TIMER) != 0) {
+      out[filled].udata = e->udata;
+      out[filled++].events = SCRP_TIMER;
+      /* one-shot: disarm at delivery, EV_ONESHOT semantics */
+      (void)epoll_ctl(p->ep, EPOLL_CTL_DEL, e->fd, NULL);
+      close(e->fd);
+      scrp_remove(p, e);
+      continue;
+    }
+    unsigned got = 0;
+    uint32_t ep = evs[i].events;
+    if ((ep & (EPOLLIN | EPOLLHUP | EPOLLERR | EPOLLRDHUP)) != 0) got |= SCRP_READABLE;
+    if ((ep & EPOLLOUT) != 0 || ((ep & (EPOLLHUP | EPOLLERR)) != 0 && (e->mask & SCRP_WRITABLE) != 0))
+      got |= SCRP_WRITABLE;
+    got &= e->mask | SCRP_READABLE; /* EOF/err always reads; writes only if armed */
+    if (got == 0) continue;
+    out[filled].udata = e->udata;
+    out[filled++].events = got;
+  }
+  return filled;
+}
+
+#else /* !__linux__ */
+
+/* Empty TU off-Linux: the kqueue backend (scr_loop_kqueue.c) carries the
+ * macOS/BSD implementation; linking both everywhere is harmless. */
+typedef int scr_loop_epoll_unused;
+
+#endif

package/src/scr_loop_kqueue.c

@@ -0,0 +1,121 @@
+/* The macOS/BSD backend of the platform readiness contract
+ * (scr_platform.h): a thin spelling over the exact kqueue syscall
+ * sequences scr_net.c and scr_dgram.c inlined historically — the corpus
+ * pins those units' behavior byte-for-byte, so this backend adds NO state
+ * and NO extra syscalls beyond what the inline code issued:
+ *
+ * - watch read/write     EV_SET(fd, EVFILT_READ/WRITE, EV_ADD/EV_DELETE,
+ *                        0, 0, udata) + a zero-timeout kevent, failures
+ *                        ignored exactly as the units always ignored them
+ *                        (EV_DELETE of a missing filter included).
+ * - one-shot timer(key)  EVFILT_TIMER ident=(uintptr_t)key, EV_ADD|
+ *                        EV_ONESHOT, data in milliseconds (the default
+ *                        unit) — scr_net's idle-timer spelling; EV_ADD on
+ *                        an armed ident re-arms, EV_DELETE of a fired one
+ *                        is the ignored "may already have fired" case.
+ * - forget(fd)           a NO-OP: kqueue drops an fd's filters when the
+ *                        fd closes, and the historical code relied on
+ *                        exactly that. The call exists for the epoll
+ *                        backend, where a watched fd MUST be deregistered
+ *                        before close(2) (see scr_platform.h).
+ * - drain                kevent(NULL, 0, evs, N, {0,0}); each kevent maps
+ *                        to ONE ScrPollerEvent with a single SCRP_* bit
+ *                        (kqueue's separate filters never coalesce), so
+ *                        dispatch order through the contract is the
+ *                        kernel's delivery order, unchanged.
+ *
+ * No fd table lives here: kqueue keys interest by (ident, filter) and
+ * carries udata per filter, so the kernel IS the table. The epoll backend
+ * (scr_loop_epoll.c) is the stateful one. */
+#if defined(__APPLE__) || defined(__FreeBSD__) || defined(__NetBSD__) || \
+    defined(__OpenBSD__) || defined(__DragonFly__)
+
+#include "scr_platform.h"
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <sys/event.h>
+#include <sys/time.h>
+#include <unistd.h>
+
+struct ScrPoller {
+  int kq;
+};
+
+ScrPoller *scrp_poller_new(void) {
+  ScrPoller *p = malloc(sizeof *p);
+  if (p == NULL) return NULL;
+  p->kq = kqueue();
+  if (p->kq < 0) {
+    free(p);
+    return NULL;
+  }
+  return p;
+}
+
+void scrp_poller_free(ScrPoller *p) {
+  if (p == NULL) return;
+  close(p->kq);
+  free(p);
+}
+
+int scrp_poller_fd(const ScrPoller *p) { return p->kq; }
+
+static bool scrp_kev(ScrPoller *p, uintptr_t ident, int16_t filter, uint16_t flags,
+                     int64_t data, void *udata) {
+  struct kevent ev;
+  EV_SET(&ev, ident, filter, flags, 0, data, udata);
+  struct timespec zero = {0, 0};
+  return kevent(p->kq, &ev, 1, NULL, 0, &zero) == 0;
+}
+
+bool scrp_watch_read(ScrPoller *p, int fd, void *udata, bool on) {
+  if (fd < 0) return true; /* the historical guard in scr_net_filter */
+  return scrp_kev(p, (uintptr_t)fd, EVFILT_READ, on ? EV_ADD : EV_DELETE, 0, udata);
+}
+
+bool scrp_watch_write(ScrPoller *p, int fd, void *udata, bool on) {
+  if (fd < 0) return true;
+  return scrp_kev(p, (uintptr_t)fd, EVFILT_WRITE, on ? EV_ADD : EV_DELETE, 0, udata);
+}
+
+void scrp_forget(ScrPoller *p, int fd) {
+  /* Deliberately nothing: close(2) drops the fd's filters, which is what
+   * the inline code always relied on. Removing them here would ADD
+   * syscalls the historical sequence never issued. */
+  (void)p;
+  (void)fd;
+}
+
+bool scrp_timer_arm(ScrPoller *p, void *key, double ms, void *udata) {
+  return scrp_kev(p, (uintptr_t)key, EVFILT_TIMER, EV_ADD | EV_ONESHOT, (int64_t)ms, udata);
+}
+
+void scrp_timer_cancel(ScrPoller *p, void *key) {
+  /* May already have fired — the failure is ignored, as always. */
+  (void)scrp_kev(p, (uintptr_t)key, EVFILT_TIMER, EV_DELETE, 0, NULL);
+}
+
+int scrp_drain(ScrPoller *p, ScrPollerEvent *out, int max) {
+  if (max <= 0) return 0;
+  struct kevent evs[64];
+  int want = max < 64 ? max : 64;
+  struct timespec zero = {0, 0};
+  int n = kevent(p->kq, NULL, 0, evs, want, &zero);
+  if (n <= 0) return 0; /* EINTR/none: a spurious pass, as today */
+  for (int i = 0; i < n; i++) {
+    out[i].udata = evs[i].udata;
+    out[i].events = evs[i].filter == EVFILT_TIMER   ? SCRP_TIMER
+                    : evs[i].filter == EVFILT_WRITE ? SCRP_WRITABLE
+                                                    : SCRP_READABLE;
+  }
+  return n;
+}
+
+#else /* !BSD */
+
+/* Empty TU off-BSD: the epoll backend (scr_loop_epoll.c) carries the
+ * Linux implementation; linking both everywhere is harmless. */
+typedef int scr_loop_kqueue_unused;
+
+#endif

package/src/scr_loop_wsapoll.c

@@ -0,0 +1,208 @@
+/* The Windows backend of the platform readiness contract (scr_platform.h):
+ * WSAPoll for socket readiness, deadline bookkeeping for the one-shot
+ * timers (no timerfd analogue — scrp_drain expires due keys against the
+ * loop's scr_now_ms clock). cc.ts links this TU alongside the kqueue and
+ * epoll backends whenever a poller-using unit compiles; each is empty off
+ * its platform.
+ *
+ * Design notes:
+ * - Interest lives in the same linear fd -> (mask, udata) table the epoll
+ *   backend keeps, but there is no kernel registration at all: every
+ *   scrp_drain builds a WSAPOLLFD array from the table and polls it with
+ *   a zero timeout. At the units' scale (dozens of sockets) the rebuild
+ *   is noise, and it makes forget/close ordering unable to go stale by
+ *   construction — an entry gone from the table is gone from the poll.
+ * - There is NO pollable poller fd to hand the loop (WSAPoll has no
+ *   waitable handle shape): scrp_poller_fd answers -1 and the loop's
+ *   win32 idle sleep runs capped (scr_async.c), dispatching at the next
+ *   turn's top — readiness latency is bounded by the cap instead of
+ *   eliminated by a wake fd. When that cap ever shows up in a profile,
+ *   the upgrade path is WSAEventSelect + WaitForMultipleObjects (or
+ *   IOCP), which needs a loop-side seam, not a contract change.
+ * - POLLHUP/POLLERR report as READABLE (plus WRITABLE when write interest
+ *   is armed) exactly like the epoll backend: units learn the truth from
+ *   recv()==0 / the socket error. A failed nonblocking connect() reports
+ *   through POLLERR/POLLHUP here (WSAPoll delivers those on Win10 19041+;
+ *   the box class this lane targets).
+ * - fds are winsock SOCKETs narrowed through the units' int fd contract
+ *   and widened back here; Windows socket handles fit (kernel handle
+ *   space), the same narrowing scr_child.c's stdio plumbing relies on.
+ * - WSAStartup: the owning unit (scr_net.c/scr_dgram.c) initializes
+ *   winsock before it creates sockets; poller_new also calls it (ref-
+ *   counted by the OS) so a poller created first still works. */
+#ifdef _WIN32
+
+#include "scr_platform.h"
+#include "scr_runtime.h"
+
+#include <stdlib.h>
+#include <string.h>
+#include <winsock2.h>
+
+typedef struct {
+  int fd;          /* watched SOCKET (narrowed), or -1 for a timer entry */
+  unsigned mask;   /* SCRP_READABLE|SCRP_WRITABLE, or SCRP_TIMER */
+  void *udata;     /* delivery tag; for timers: the arm-time udata */
+  void *timer_key; /* timers only: the caller's key */
+  double deadline; /* timers only: scr_now_ms deadline */
+} ScrpEntry;
+
+struct ScrPoller {
+  ScrpEntry *entries;
+  size_t n, cap;
+};
+
+static ScrpEntry *scrp_find_fd(ScrPoller *p, int fd) {
+  for (size_t i = 0; i < p->n; i++)
+    if ((p->entries[i].mask & SCRP_TIMER) == 0 && p->entries[i].fd == fd) return &p->entries[i];
+  return NULL;
+}
+
+static ScrpEntry *scrp_find_key(ScrPoller *p, void *key) {
+  for (size_t i = 0; i < p->n; i++)
+    if ((p->entries[i].mask & SCRP_TIMER) != 0 && p->entries[i].timer_key == key) return &p->entries[i];
+  return NULL;
+}
+
+static void scrp_remove(ScrPoller *p, ScrpEntry *e) {
+  size_t i = (size_t)(e - p->entries);
+  p->entries[i] = p->entries[p->n - 1];
+  p->n--;
+}
+
+static bool scrp_push(ScrPoller *p, ScrpEntry e) {
+  if (p->n == p->cap) {
+    size_t cap = p->cap == 0 ? 16 : p->cap * 2;
+    ScrpEntry *grown = realloc(p->entries, cap * sizeof *grown);
+    if (grown == NULL) return false;
+    p->entries = grown;
+    p->cap = cap;
+  }
+  p->entries[p->n++] = e;
+  return true;
+}
+
+ScrPoller *scrp_poller_new(void) {
+  WSADATA wsa;
+  if (WSAStartup(MAKEWORD(2, 2), &wsa) != 0) return NULL;
+  ScrPoller *p = calloc(1, sizeof *p);
+  if (p == NULL) WSACleanup();
+  return p;
+}
+
+void scrp_poller_free(ScrPoller *p) {
+  if (p == NULL) return;
+  free(p->entries);
+  free(p);
+  WSACleanup();
+}
+
+int scrp_poller_fd(const ScrPoller *p) {
+  (void)p;
+  return -1; /* nothing waitable — the loop's capped win32 sleep serves us */
+}
+
+static bool scrp_watch(ScrPoller *p, int fd, void *udata, bool on, unsigned bit) {
+  ScrpEntry *e = scrp_find_fd(p, fd);
+  unsigned mask = e != NULL ? e->mask : 0u;
+  unsigned next = on ? (mask | bit) : (mask & ~bit);
+  if (e == NULL) {
+    if (next == 0) return true; /* unwatch of an unwatched fd: no-op */
+    return scrp_push(p, (ScrpEntry){fd, next, udata, NULL, 0});
+  }
+  if (next == 0) {
+    scrp_remove(p, e);
+    return true;
+  }
+  e->mask = next;
+  e->udata = udata; /* last registration wins, both directions */
+  return true;
+}
+
+bool scrp_watch_read(ScrPoller *p, int fd, void *udata, bool on) {
+  return scrp_watch(p, fd, udata, on, SCRP_READABLE);
+}
+
+bool scrp_watch_write(ScrPoller *p, int fd, void *udata, bool on) {
+  return scrp_watch(p, fd, udata, on, SCRP_WRITABLE);
+}
+
+void scrp_forget(ScrPoller *p, int fd) {
+  ScrpEntry *e = scrp_find_fd(p, fd);
+  if (e != NULL) scrp_remove(p, e);
+}
+
+bool scrp_timer_arm(ScrPoller *p, void *key, double ms, void *udata) {
+  if (!(ms >= 0)) ms = 0;
+  double deadline = scr_now_ms() + ms;
+  ScrpEntry *e = scrp_find_key(p, key);
+  if (e != NULL) {
+    e->deadline = deadline; /* re-arm replaces the deadline */
+    e->udata = udata;
+    return true;
+  }
+  return scrp_push(p, (ScrpEntry){-1, SCRP_TIMER, udata, key, deadline});
+}
+
+void scrp_timer_cancel(ScrPoller *p, void *key) {
+  ScrpEntry *e = scrp_find_key(p, key);
+  if (e != NULL) scrp_remove(p, e); /* unarmed or already fired: no-op */
+}
+
+int scrp_drain(ScrPoller *p, ScrPollerEvent *out, int max) {
+  if (max <= 0) return 0;
+  int filled = 0;
+  /* Due timers first (kqueue delivers EVFILT_TIMER through the same
+   * drain); one-shot — the entry leaves the table at delivery. */
+  double now = scr_now_ms();
+  for (size_t i = 0; i < p->n && filled < max;) {
+    ScrpEntry *e = &p->entries[i];
+    if ((e->mask & SCRP_TIMER) != 0 && e->deadline <= now) {
+      out[filled].udata = e->udata;
+      out[filled++].events = SCRP_TIMER;
+      scrp_remove(p, e); /* swaps the tail in — revisit index i */
+      continue;
+    }
+    i++;
+  }
+  /* Socket readiness: poll the whole table with a zero timeout. */
+  enum { SCRP_BATCH = 64 };
+  WSAPOLLFD pfds[SCRP_BATCH];
+  ScrpEntry *owners[SCRP_BATCH];
+  ULONG npfds = 0;
+  for (size_t i = 0; i < p->n && npfds < SCRP_BATCH; i++) {
+    ScrpEntry *e = &p->entries[i];
+    if ((e->mask & SCRP_TIMER) != 0) continue;
+    pfds[npfds].fd = (SOCKET)e->fd;
+    pfds[npfds].events = 0;
+    if ((e->mask & SCRP_READABLE) != 0) pfds[npfds].events |= POLLRDNORM;
+    if ((e->mask & SCRP_WRITABLE) != 0) pfds[npfds].events |= POLLWRNORM;
+    pfds[npfds].revents = 0;
+    owners[npfds++] = e;
+  }
+  if (npfds == 0 || filled >= max) return filled;
+  int n = WSAPoll(pfds, npfds, 0);
+  if (n <= 0) return filled; /* none/failed: a spurious pass */
+  for (ULONG i = 0; i < npfds && filled < max; i++) {
+    SHORT re = pfds[i].revents;
+    if (re == 0) continue;
+    ScrpEntry *e = owners[i];
+    unsigned got = 0;
+    if ((re & (POLLRDNORM | POLLHUP | POLLERR | POLLNVAL)) != 0) got |= SCRP_READABLE;
+    if ((re & POLLWRNORM) != 0 || ((re & (POLLHUP | POLLERR | POLLNVAL)) != 0 && (e->mask & SCRP_WRITABLE) != 0))
+      got |= SCRP_WRITABLE;
+    got &= e->mask | SCRP_READABLE; /* EOF/err always reads; writes only if armed */
+    if (got == 0) continue;
+    out[filled].udata = e->udata;
+    out[filled++].events = got;
+  }
+  return filled;
+}
+
+#else /* !_WIN32 */
+
+/* Empty TU off-Windows: the kqueue and epoll backends carry the POSIX
+ * platforms; linking all three everywhere is harmless. */
+typedef int scr_loop_wsapoll_unused;
+
+#endif