@velox0/cerver 0.6.1 → 0.6.2

package/lib/commands/run.js

@@ -18,7 +18,6 @@ function run(opts) {
   }
   process.chdir(projectDir);
 
-  // Prefer .exe on Windows, fall back to plain "server" for compat
   const binaryName  = IS_WINDOWS ? "server.exe" : "server";
   const binaryPath  = path.join(projectDir, "dist", binaryName);
   const legacyPath  = path.join(projectDir, "dist", "server");
@@ -49,7 +48,7 @@ function run(opts) {
       stdio: "inherit",
       env,
       cwd:   projectDir,
-      shell: IS_WINDOWS, // On Windows, .exe may need shell resolution
+      shell: IS_WINDOWS,
     });
   } catch (err) {
     if (err.status !== null) {

package/lib/compiler/compile.js

@@ -12,8 +12,6 @@ const IS_WINDOWS = process.platform === "win32";
 /* ------------------------------------------------------------------ */
 
 function detectCompiler() {
-  // On Windows, prefer clang (bundled with VS/LLVM) then gcc (MinGW/MSYS2)
-  // On Unix, keep original preference order
   const candidates = IS_WINDOWS
     ? ["clang", "gcc", "cc", "x86_64-w64-mingw32-gcc"]
     : ["cc", "gcc", "clang"];
@@ -21,7 +19,6 @@ function detectCompiler() {
   for (const cc of candidates) {
     try {
       if (IS_WINDOWS) {
-        // `which` doesn't exist on Windows; use `where`
         execFileSync("where", [cc], { stdio: "ignore", shell: false });
       } else {
         execFileSync("which", [cc], { stdio: "ignore" });
@@ -55,7 +52,7 @@ function supportsFlag(cc, flag) {
       {
         input: "int main(){}\n",
         stdio: ["pipe", "ignore", "ignore"],
-        shell: IS_WINDOWS, // MinGW on Windows sometimes needs shell
+        shell: IS_WINDOWS,
       }
     );
     return true;
@@ -174,7 +171,7 @@ function compile(distDir, runtimeDir, opts) {
     }
 
     /* Windows-specific defines */
-    args.push("-D_WIN32_WINNT=0x0601"); // Windows 7+
+    args.push("-D_WIN32_WINNT=0x0601");
     args.push("-DWIN32_LEAN_AND_MEAN");
 
     /* Produce a console binary (not a GUI window) */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@velox0/cerver",
-  "version": "0.6.1",
+  "version": "0.6.2",
   "description": "Compile restricted JavaScript server logic into optimized native C binaries (cross-platform: Linux, macOS, Windows)",
   "main": "bin/cerver.js",
   "bin": {

package/runtime/cerver.h

@@ -304,4 +304,4 @@ int  cerver_stat_cache_lookup(cerver_stat_cache_t* cache, const char* path, size
 void cerver_stat_cache_store(cerver_stat_cache_t* cache, const char* path, size_t file_size,
                              time_t mtime);
 
-#endif /* CERVER_H */
+#endif  // CERVER_H

package/runtime/http_writer.c

@@ -16,7 +16,7 @@
 #if !CERVER_PLATFORM_WINDOWS
 #include <unistd.h>
 #include <sys/uio.h>
-#endif
+#endif  // !CERVER_PLATFORM_WINDOWS
 
 /* ------------------------------------------------------------------ */
 /*  sendfile — read-write fallback everywhere                         */
@@ -64,7 +64,7 @@ static ssize_t do_sendfile(cerver_sock_t out_fd, int in_fd, off_t offset, size_t
   if (lseek(in_fd, offset, SEEK_SET) == -1) return -1;
   size_t  to_read = count > sizeof(buf) ? sizeof(buf) : count;
   ssize_t n_read  = read(in_fd, buf, to_read);
-#endif
+#endif  // CERVER_PLATFORM_WINDOWS
   if (n_read <= 0) return (ssize_t)n_read;
   size_t written = 0;
   while (written < (size_t)n_read) {
@@ -74,7 +74,8 @@ static ssize_t do_sendfile(cerver_sock_t out_fd, int in_fd, off_t offset, size_t
   }
   return (ssize_t)written;
 }
-#endif
+#endif  // __linux__ && !CERVER_PLATFORM_WINDOWS
+        // !CERVER_PLATFORM_WINDOWS, else
 
 /* ------------------------------------------------------------------ */
 /*  Portable full-write helper (send all bytes)                       */
@@ -87,7 +88,7 @@ static int send_all(cerver_sock_t fd, const char* buf, size_t len) {
     if (n < 0) {
 #if !CERVER_PLATFORM_WINDOWS
       if (errno == EINTR) continue;
-#endif
+#endif  // !CERVER_PLATFORM_WINDOWS
       return -1;
     }
     sent += (size_t)n;
@@ -167,7 +168,7 @@ int cerver_write_response(int fd, const cerver_response_t* res, int keepalive) {
       if (n < 0) {
 #if !CERVER_PLATFORM_WINDOWS
         if (errno == EINTR) continue;
-#endif
+#endif  // !CERVER_PLATFORM_WINDOWS
         return -1;
       }
       if (n == 0) break;

package/runtime/server.c

@@ -34,7 +34,7 @@
 #include <netinet/in.h>
 #include <netinet/tcp.h>
 #include <arpa/inet.h>
-#endif
+#endif  // !CERVER_PLATFORM_WINDOWS
 
 #if defined(__APPLE__) || defined(__FreeBSD__)
 #define CERVER_USE_KQUEUE 1
@@ -49,11 +49,12 @@
 #else
 #define CERVER_USE_SELECT 1
 #include <sys/select.h>
-#endif
+#endif  // __APPLE__ || __FreeBSD__
+        // CERVER_PLATFORM_WINDOWS, else
 
 #ifdef __linux__
 #include <sched.h>
-#endif
+#endif  // __linux__
 
 /* Connection pool sizing */
 #define CERVER_CONN_POOL_SIZE  128
@@ -74,7 +75,7 @@ static void* cerver_memmem(const void* hay, size_t haylen, const void* needle, s
   return NULL;
 }
 #define memmem cerver_memmem
-#endif
+#endif  // !CERVER_PLATFORM_WINDOWS && !__APPLE__ && !_GNU_SOURCE
 
 /* Global for signal handler */
 static cerver_server_t* g_srv = NULL;
@@ -95,7 +96,7 @@ static int set_nonblocking(cerver_sock_t fd) {
   int flags = fcntl(fd, F_GETFL, 0);
   if (flags < 0) return -1;
   return fcntl(fd, F_SETFL, flags | O_NONBLOCK);
-#endif
+#endif  // CERVER_PLATFORM_WINDOWS
 }
 
 static int get_cpu_count(void) {
@@ -103,7 +104,7 @@ static int get_cpu_count(void) {
   long n = cerver_nproc_win();
 #else
   long n = sysconf(_SC_NPROCESSORS_ONLN);
-#endif
+#endif  // CERVER_PLATFORM_WINDOWS
   if (n < 1) n = 1;
   if (n > 64) n = 64;
   return (int)n;
@@ -209,11 +210,6 @@ static char* read_full_request(cerver_sock_t fd, size_t* out_len) {
   char*  buf = malloc(cap + 1);
   if (!buf) return NULL;
 
-#if CERVER_PLATFORM_WINDOWS
-  /* On Windows set a blocking recv timeout via SO_RCVTIMEO (already set
-     per-connection in handle_connection).  Just read normally. */
-#endif
-
   while (len < (size_t)CERVER_READ_BUF_MAX) {
     ssize_t n = (ssize_t)cerver_sock_read(fd, buf + len, cap - len);
     if (n <= 0) break;
@@ -252,7 +248,7 @@ static void handle_connection(cerver_server_t* srv, cerver_sock_t client_fd) {
     int flags = fcntl(client_fd, F_GETFL, 0);
     if (flags >= 0 && (flags & O_NONBLOCK)) fcntl(client_fd, F_SETFL, flags & ~O_NONBLOCK);
   }
-#endif
+#endif  // !CERVER_PLATFORM_WINDOWS
 
   /* TCP_NODELAY */
   {
@@ -272,7 +268,7 @@ static void handle_connection(cerver_server_t* srv, cerver_sock_t client_fd) {
 #else
     struct timeval tv = {timeout_sec, 0};
     setsockopt(client_fd, SOL_SOCKET, SO_RCVTIMEO, CERVER_SETSOCKOPT_CAST & tv, sizeof(tv));
-#endif
+#endif  // CERVER_PLATFORM_WINDOWS
 
     size_t req_len = 0;
     char*  buf     = read_full_request(client_fd, &req_len);
@@ -300,7 +296,7 @@ static void handle_connection(cerver_server_t* srv, cerver_sock_t client_fd) {
     memset(&res, 0, sizeof(res));
 #if !CERVER_PLATFORM_WINDOWS
     res._file_fd = -1;
-#endif
+#endif  // !CERVER_PLATFORM_WINDOWS
 
     if (cerver_serve_static(srv, &req, &res) < 0) {
       cerver_handler_fn handler = cerver_dispatch(srv, &req);
@@ -321,7 +317,7 @@ static void handle_connection(cerver_server_t* srv, cerver_sock_t client_fd) {
       munmap((void*)res.body, res.body_len);
     else if (res._body_owned == 3 && res._file_fd >= 0)
       close(res._file_fd);
-#endif
+#endif  // !CERVER_PLATFORM_WINDOWS
 
     free(buf);
     if (write_err < 0) break;
@@ -391,7 +387,7 @@ static cerver_sock_t create_listener(int port, int reuseport) {
     perror("cerver: socket");
     return CERVER_INVALID_SOCK;
   }
-#endif
+#endif  // CERVER_PLATFORM_WINDOWS
 
   int opt = 1;
   setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, CERVER_SETSOCKOPT_CAST & opt, sizeof(opt));
@@ -400,7 +396,7 @@ static cerver_sock_t create_listener(int port, int reuseport) {
   if (reuseport) setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &opt, sizeof(opt));
 #else
   (void)reuseport;
-#endif
+#endif  // __linux__ || __APPLE__ || __FreeBSD__
 
   struct sockaddr_in addr;
   memset(&addr, 0, sizeof(addr));
@@ -434,7 +430,7 @@ static cerver_sock_t accept_connection(cerver_sock_t listen_fd) {
   return accept4(listen_fd, (struct sockaddr*)&ca, &cl, SOCK_CLOEXEC);
 #else
   return accept(listen_fd, (struct sockaddr*)&ca, &cl);
-#endif
+#endif  // __linux__
 }
 
 /* ------------------------------------------------------------------ */
@@ -553,7 +549,7 @@ static void* acceptor_loop(void* arg) {
   return NULL;
 }
 
-#else /* SELECT — used on Windows and other POSIX platforms */
+#else
 
 static void* acceptor_loop(void* arg) {
   cerver_worker_t* w   = (cerver_worker_t*)arg;
@@ -578,13 +574,13 @@ static void* acceptor_loop(void* arg) {
 #else
     struct timeval tv  = {1, 0};
     int            ret = select((int)w->listen_fd + 1, &rfds, NULL, NULL, &tv);
-#endif
+#endif  // CERVER_PLATFORM_WINDOWS
     if (ret < 0) {
 #if CERVER_PLATFORM_WINDOWS
       if (WSAGetLastError() == WSAEINTR) continue;
 #else
       if (errno == EINTR) continue;
-#endif
+#endif  // CERVER_PLATFORM_WINDOWS
       break;
     }
     if (ret > 0 && FD_ISSET(w->listen_fd, &rfds)) {
@@ -595,7 +591,7 @@ static void* acceptor_loop(void* arg) {
           if (cerver_would_block_win()) break;
 #else
           if (errno == EAGAIN || errno == EWOULDBLOCK) break;
-#endif
+#endif  // CERVER_PLATFORM_WINDOWS
           break;
         }
         if (cq_push(&g_conn_queue, cfd) < 0) {
@@ -606,7 +602,7 @@ static void* acceptor_loop(void* arg) {
   }
   return NULL;
 }
-#endif /* acceptor backends */
+#endif  // CERVER_USE_KQUEUE
 
 /* ------------------------------------------------------------------ */
 /*  Stat cache                                                        */
@@ -676,7 +672,7 @@ int cerver_init(cerver_server_t* srv, int port, int threads) {
   cerver_stat_cache_init(&srv->stat_cache);
 #if CERVER_PLATFORM_WINDOWS
   cerver_wsa_startup();
-#endif
+#endif  // CERVER_PLATFORM_WINDOWS
   return 0;
 }
 
@@ -709,7 +705,7 @@ int cerver_listen(cerver_server_t* srv) {
   signal(SIGTERM, signal_handler);
 #if !CERVER_PLATFORM_WINDOWS
   signal(SIGPIPE, SIG_IGN);
-#endif
+#endif  // !CERVER_PLATFORM_WINDOWS
 
   srv->running        = 1;
   srv->acceptor_count = 0;
@@ -723,7 +719,7 @@ int cerver_listen(cerver_server_t* srv) {
   /* Windows select-based acceptor: limit to 1 until IOCP is wired */
 #if CERVER_PLATFORM_WINDOWS
   acceptor_count = 1;
-#endif
+#endif  // CERVER_PLATFORM_WINDOWS
 
   int pool_size = configured_worker_count * 16;
   if (pool_size < CERVER_CONN_POOL_SIZE) pool_size = CERVER_CONN_POOL_SIZE;
@@ -802,7 +798,7 @@ int cerver_listen(cerver_server_t* srv) {
     if (w->listen_fd == CERVER_INVALID_SOCK) w->listen_fd = srv->sock_fd;
 #else
     w->listen_fd = srv->sock_fd;
-#endif
+#endif  // __linux__ || __APPLE__ || __FreeBSD__
     if (pthread_create(&w->thread, &attr, acceptor_loop, w) != 0) {
       perror("cerver: acceptor create");
       srv->running = 0;
@@ -875,13 +871,13 @@ void cerver_shutdown(cerver_server_t* srv) {
       if (srv->workers[i].listen_fd != srv->sock_fd &&
           srv->workers[i].listen_fd != CERVER_INVALID_SOCK)
         cerver_platform_close(srv->workers[i].listen_fd);
-#endif
+#endif  // __linux__ || __APPLE__ || __FreeBSD__
       if (srv->workers[i].event_fd >= 0)
 #if !CERVER_PLATFORM_WINDOWS
         close(srv->workers[i].event_fd);
 #else
         closesocket((SOCKET)srv->workers[i].event_fd);
-#endif
+#endif  // !CERVER_PLATFORM_WINDOWS
     }
     free(srv->workers);
     srv->workers = NULL;
@@ -902,7 +898,7 @@ void cerver_shutdown(cerver_server_t* srv) {
 
 #if CERVER_PLATFORM_WINDOWS
   cerver_wsa_cleanup();
-#endif
+#endif  // CERVER_PLATFORM_WINDOWS
 
   printf("\ncerver: server stopped\n");
 }

package/runtime/static.c

@@ -19,11 +19,11 @@
 #include <unistd.h>
 #include <fcntl.h>
 #include <sys/mman.h>
-#endif
+#endif  // !CERVER_PLATFORM_WINDOWS
 
 #ifdef __linux__
 #include <sys/sendfile.h>
-#endif
+#endif  // __linux__
 
 /* ------------------------------------------------------------------ */
 /*  FNV-1a hash for fast asset lookup                                 */
@@ -257,7 +257,7 @@ static int serve_filesystem(cerver_server_t* srv, cerver_request_t* req, cerver_
   int fd = _open(full_path, _O_RDONLY | _O_BINARY);
 #else
   int fd = open(full_path, O_RDONLY);
-#endif
+#endif  // CERVER_PLATFORM_WINDOWS
   if (fd < 0) return -1;
 
   res->status       = 200;

package/runtime/tests/minunit.h

@@ -61,4 +61,4 @@ const char* mu_snip(const char* s, char* buf, size_t cap);
     }                                                                               \
   } while (0)
 
-#endif
+#endif  // CERVER_MINUNIT_H

package/runtime/win_compat.h

@@ -14,10 +14,10 @@
 /* ---- winsock / windows ------------------------------------------ */
 #ifndef WIN32_LEAN_AND_MEAN
 #define WIN32_LEAN_AND_MEAN
-#endif
+#endif  // WIN32_LEAN_AND_MEAN
 #ifndef _WIN32_WINNT
 #define _WIN32_WINNT 0x0601 /* Windows 7+ */
-#endif
+#endif                      // _WIN32_WINNT
 #include <winsock2.h>
 #include <ws2tcpip.h>
 #include <windows.h>
@@ -30,7 +30,7 @@
    can stay unchanged.  Only the primitives actually used by cerver are
    mapped; this is NOT a general replacement.                          */
 
-#include <pthread.h> /* pthreads4w / pthreads-win32, installed via mingw */
+#include <pthread.h>
 
 /* ---- POSIX socket aliases --------------------------------------- */
 typedef SOCKET cerver_sock_t;
@@ -41,7 +41,7 @@ typedef SOCKET cerver_sock_t;
 #if !defined(ssize_t) && !defined(_SSIZE_T_DEFINED)
 typedef intptr_t ssize_t;
 #define _SSIZE_T_DEFINED
-#endif
+#endif  // !ssize_t && !_SSIZE_T_DEFINED
 
 /* read/write on a socket must go through recv/send on Windows */
 static inline ssize_t cerver_sock_read(int fd, void* buf, size_t n) {
@@ -75,7 +75,7 @@ static inline void* cerver_memmem_win(const void* hay, size_t hlen, const void*
 }
 #ifndef memmem
 #define memmem cerver_memmem_win
-#endif
+#endif  // memmem
 
 /* clock_gettime is missing before MSVC 2019 / older MinGW */
 #if defined(_MSC_VER) && _MSC_VER < 1900
@@ -96,8 +96,8 @@ static inline int clock_gettime(int, struct timespec* ts) {
   ts->tv_nsec = (long)((t % 10000000ULL) * 100);
   return 0;
 }
-#endif
-#endif
+#endif  // CLOCK_REALTIME
+#endif  // _MSC_VER && _MSC_VER < 1900
 
 /* Windows socket error → errno translation for the few codes we check */
 static inline int cerver_would_block_win(void) {
@@ -116,12 +116,12 @@ static inline long cerver_nproc_win(void) {
 /* sleep(n) → Sleep(n*1000) */
 #ifndef sleep
 #define sleep(n) Sleep((DWORD)((n) * 1000))
-#endif
+#endif  // sleep
 
 /* Signal shim — Windows has signal() but not SIGPIPE */
 #ifndef SIGPIPE
 #define SIGPIPE 13
-#endif
+#endif  // SIGPIPE
 /* SIG_IGN is defined in <signal.h> on Windows */
 
 /* Winsock init/teardown helpers ----------------------------------- */
@@ -136,9 +136,9 @@ static inline void cerver_wsa_cleanup(void) { WSACleanup(); }
 
 #else /* !Windows */
 
-#include <stddef.h>    /* size_t */
-#include <sys/types.h> /* ssize_t */
-#include <unistd.h>    /* read, write, close */
+#include <stddef.h>
+#include <sys/types.h>
+#include <unistd.h>
 
 #define CERVER_PLATFORM_WINDOWS 0
 typedef int           cerver_sock_t;
@@ -153,5 +153,5 @@ static inline ssize_t cerver_sock_write(int fd, const void* buf, size_t n) {
 static inline int  cerver_wsa_startup(void) { return 0; }
 static inline void cerver_wsa_cleanup(void) {}
 
-#endif /* _WIN32 */
-#endif /* CERVER_WIN_COMPAT_H */
+#endif  // _WIN32 || _WIN64
+#endif  // CERVER_WIN_COMPAT_H