@velox0/cerver 0.4.1 → 0.4.3

package/lib/ir/transform.js

@@ -6,7 +6,7 @@ const IR = require("./types");
  * Transform a validated AST into an IR route descriptor.
  *
  * @param {object} ast - ESTree AST (validated)
- * @param {string} urlPath - The route path (e.g. "/art/:key")
+ * @param {string} urlPath - The route path (e.g. "/groups/:group_id")
  * @returns {IRRoute[]} — one IRRoute per exported handler (GET, POST)
  */
 function transformFile(ast, urlPath) {
@@ -135,11 +135,7 @@ function transformReturn(node, ctx) {
   }
 
   /* Plain expression return — treat as text */
-  return IR.IRReturn(
-    "text",
-    200,
-    transformExpression(arg, ctx)
-  );
+  return IR.IRReturn("text", 200, transformExpression(arg, ctx));
 }
 
 /**
@@ -148,9 +144,13 @@ function transformReturn(node, ctx) {
 function transformIf(node, ctx) {
   const condition = transformExpression(node.test, ctx);
 
-  const thenBlock = node.consequent.type === "BlockStatement"
-    ? transformBlock(node.consequent, ctx)
-    : { variables: [], body: [transformStatement(node.consequent, ctx)].filter(Boolean) };
+  const thenBlock =
+    node.consequent.type === "BlockStatement"
+      ? transformBlock(node.consequent, ctx)
+      : {
+          variables: [],
+          body: [transformStatement(node.consequent, ctx)].filter(Boolean),
+        };
 
   let elseBody = null;
   if (node.alternate) {
@@ -208,28 +208,25 @@ function transformExpression(node, ctx) {
       return IR.IRComparison(
         node.operator,
         transformExpression(node.left, ctx),
-        transformExpression(node.right, ctx)
+        transformExpression(node.right, ctx),
       );
 
     case "LogicalExpression":
       return IR.IRLogical(
         node.operator,
         transformExpression(node.left, ctx),
-        transformExpression(node.right, ctx)
+        transformExpression(node.right, ctx),
       );
 
     case "UnaryExpression":
-      return IR.IRUnary(
-        node.operator,
-        transformExpression(node.argument, ctx)
-      );
+      return IR.IRUnary(node.operator, transformExpression(node.argument, ctx));
 
     case "ConditionalExpression":
       /* a ? b : c → IR.IRIf as expression — simplify to if/else for now */
       return IR.IRComparison(
         "?:",
         transformExpression(node.test, ctx),
-        transformExpression(node.consequent, ctx)
+        transformExpression(node.consequent, ctx),
       );
 
     case "MemberExpression":
@@ -274,10 +271,7 @@ function transformMemberExpr(node, ctx) {
   }
 
   /* req.method, req.path */
-  if (
-    node.object.type === "Identifier" &&
-    node.object.name === ctx.reqName
-  ) {
+  if (node.object.type === "Identifier" && node.object.name === ctx.reqName) {
     const prop = node.property.name || node.property.value;
     if (prop === "method") return IR.IRIdentifier("req->method");
     if (prop === "path") return IR.IRIdentifier("req->path");

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@velox0/cerver",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "description": "Compile restricted JavaScript server logic into optimized native C binaries",
-  "main": "lib/index.js",
+  "main": "bin/cerver.js",
   "bin": {
     "cerver": "bin/cerver.js"
   },
@@ -30,4 +30,4 @@
     "chokidar": "^3.6.0",
     "commander": "^13.1.0"
   }
-}
+}

package/runtime/cerver.h

@@ -6,6 +6,16 @@
  * the route dispatch interface.
  */
 
+/*
+ * Feature test macros for POSIX/GNU APIs used by the runtime.
+ * Must be defined before any system headers.
+ */
+#if defined(__linux__)
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+#endif
+
 #ifndef CERVER_H
 #define CERVER_H
 
@@ -69,22 +79,22 @@ typedef struct {
 
   /* Parsed query parameters */
   cerver_kv_t query[CERVER_MAX_QUERY];
-  int query_count;
+  int         query_count;
 
   /* Route parameters (from dynamic segments like :key) */
   cerver_kv_t params[CERVER_MAX_PARAMS];
-  int params_count;
+  int         params_count;
 
   /* Request headers */
   cerver_kv_t headers[CERVER_MAX_HEADERS];
-  int header_count;
+  int         header_count;
 
   /* Request body (for POST) */
   const char* body;
-  size_t body_len;
+  size_t      body_len;
 
   /* Internal: raw buffer ownership (NULL if in-place parsing used) */
-  char* _raw_buf;
+  char*  _raw_buf;
   size_t _raw_len;
 } cerver_request_t;
 
@@ -93,22 +103,25 @@ typedef struct {
 /* ------------------------------------------------------------------ */
 
 typedef struct {
-  int status;
+  int         status;
   const char* content_type;
 
   /* Response body — can be heap-allocated or static */
   const char* body;
-  size_t body_len;
+  size_t      body_len;
 
   /* Extra headers */
   cerver_kv_t headers[CERVER_MAX_HEADERS];
-  int header_count;
+  int         header_count;
 
   /* Internal flag: was body malloc'd? */
   int _body_owned;
 
   /* Keep-alive control: set to 1 to force close after response */
   int _force_close;
+
+  /* Internal file descriptor for sendfile serving */
+  int _file_fd;
 } cerver_response_t;
 
 /* Response helpers — called by generated handler code */
@@ -137,8 +150,8 @@ int cerver_req_wants_close(const cerver_request_t* req);
 typedef void (*cerver_handler_fn)(cerver_request_t* req, cerver_response_t* res);
 
 typedef struct {
-  const char* method;  /* "GET", "POST" */
-  const char* pattern; /* "/", "/art/:key", "/api/projects" */
+  const char*       method;  /* "GET", "POST" */
+  const char*       pattern; /* "/", "/groups/:group_id", "/api/items" */
   cerver_handler_fn handler;
 } cerver_route_t;
 
@@ -147,20 +160,20 @@ typedef struct {
 /* ------------------------------------------------------------------ */
 
 typedef struct {
-  const char* path;      /* e.g. "/index.html" */
-  const char* mime_type; /* e.g. "text/html" */
+  const char*          path;      /* e.g. "/index.html" */
+  const char*          mime_type; /* e.g. "text/html" */
   const unsigned char* data;
-  size_t data_len;
+  size_t               data_len;
 
   /* Pre-compressed variants (NULL if not available) */
   const unsigned char* data_gz;
-  size_t data_gz_len;
+  size_t               data_gz_len;
   const unsigned char* data_br;
-  size_t data_br_len;
+  size_t               data_br_len;
 
   /* Pre-computed response header (NULL if not generated) */
   const char* prebuilt_header;
-  size_t prebuilt_header_len;
+  size_t      prebuilt_header_len;
 } cerver_asset_t;
 
 /* ------------------------------------------------------------------ */
@@ -168,16 +181,16 @@ typedef struct {
 /* ------------------------------------------------------------------ */
 
 typedef struct {
-  char path[CERVER_MAX_PATH];
+  char   path[CERVER_MAX_PATH];
   size_t file_size;
   time_t mtime;
   time_t cached_at;
-  int valid;
+  int    valid;
 } cerver_stat_entry_t;
 
 typedef struct {
   cerver_stat_entry_t entries[CERVER_STAT_CACHE_SIZE];
-  pthread_mutex_t lock;
+  pthread_mutex_t     lock;
 } cerver_stat_cache_t;
 
 /* ------------------------------------------------------------------ */
@@ -193,11 +206,11 @@ typedef cerver_handler_fn (*cerver_dispatch_fn)(cerver_request_t* req);
 typedef struct cerver_server cerver_server_t;
 
 typedef struct {
-  int id;
-  int event_fd;  /* kqueue or epoll fd */
-  int listen_fd; /* per-worker on Linux, shared on macOS */
+  int              id;
+  int              event_fd;  /* kqueue or epoll fd */
+  int              listen_fd; /* per-worker on Linux, shared on macOS */
   cerver_server_t* srv;
-  pthread_t thread;
+  pthread_t        thread;
 } cerver_worker_t;
 
 /* ------------------------------------------------------------------ */
@@ -205,14 +218,14 @@ typedef struct {
 /* ------------------------------------------------------------------ */
 
 struct cerver_server {
-  int port;
-  int sock_fd;
+  int             port;
+  int             sock_fd;
   cerver_route_t* routes;
-  int route_count;
+  int             route_count;
   cerver_asset_t* assets;
-  int asset_count;
-  const char* public_dir; /* NULL if embedded mode */
-  volatile int running;
+  int             asset_count;
+  const char*     public_dir; /* NULL if embedded mode */
+  volatile int    running;
 
   /* Generated dispatch override (faster than generic router) */
   cerver_dispatch_fn dispatch_override;
@@ -221,17 +234,20 @@ struct cerver_server {
   cerver_stat_cache_t stat_cache;
 
   /* Worker pool */
-  int worker_count;
+  int              worker_count;
   cerver_worker_t* workers;
+
+  /* Route trie for radix/trie-based routing */
+  void*            route_trie;
 };
 
 /* Server lifecycle */
-int cerver_init(cerver_server_t* srv, int port, int threads);
-int cerver_add_routes(cerver_server_t* srv, cerver_route_t* routes, int count);
-int cerver_set_assets(cerver_server_t* srv, cerver_asset_t* assets, int count);
+int  cerver_init(cerver_server_t* srv, int port, int threads);
+int  cerver_add_routes(cerver_server_t* srv, cerver_route_t* routes, int count);
+int  cerver_set_assets(cerver_server_t* srv, cerver_asset_t* assets, int count);
 void cerver_set_public_dir(cerver_server_t* srv, const char* dir);
 void cerver_set_dispatch(cerver_server_t* srv, cerver_dispatch_fn fn);
-int cerver_listen(cerver_server_t* srv);
+int  cerver_listen(cerver_server_t* srv);
 void cerver_shutdown(cerver_server_t* srv);
 
 /* ------------------------------------------------------------------ */
@@ -250,8 +266,11 @@ int cerver_write_response(int fd, const cerver_response_t* res, int keepalive);
 /*  Router (internal)                                                 */
 /* ------------------------------------------------------------------ */
 
-int cerver_route_match(const cerver_route_t* route, cerver_request_t* req);
+int               cerver_route_match(const cerver_route_t* route, cerver_request_t* req);
 cerver_handler_fn cerver_dispatch(cerver_server_t* srv, cerver_request_t* req);
+void*             cerver_trie_create(void);
+void              cerver_trie_insert(void* trie, const char* pattern, const char* method, cerver_handler_fn handler);
+void              cerver_trie_free(void* trie);
 
 /* ------------------------------------------------------------------ */
 /*  MIME (internal)                                                   */
@@ -270,7 +289,7 @@ int cerver_serve_static(cerver_server_t* srv, cerver_request_t* req, cerver_resp
 /* ------------------------------------------------------------------ */
 
 void cerver_stat_cache_init(cerver_stat_cache_t* cache);
-int cerver_stat_cache_lookup(cerver_stat_cache_t* cache, const char* path, size_t* file_size);
+int  cerver_stat_cache_lookup(cerver_stat_cache_t* cache, const char* path, size_t* file_size);
 void cerver_stat_cache_store(cerver_stat_cache_t* cache, const char* path, size_t file_size,
                              time_t mtime);
 

package/runtime/http_parser.c

@@ -11,6 +11,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <strings.h>
 #include <ctype.h>
 
 /* ------------------------------------------------------------------ */
@@ -67,13 +68,13 @@ static void parse_query_string(char* qs, cerver_request_t* req) {
 
     char* eq = strchr(pair_start, '=');
     if (eq) {
-      *eq = '\0';
-      req->query[req->query_count].key = pair_start;
+      *eq                                = '\0';
+      req->query[req->query_count].key   = pair_start;
       req->query[req->query_count].value = eq + 1;
       url_decode((char*)req->query[req->query_count].key);
       url_decode((char*)req->query[req->query_count].value);
     } else {
-      req->query[req->query_count].key = pair_start;
+      req->query[req->query_count].key   = pair_start;
       req->query[req->query_count].value = "";
     }
     req->query_count++;
@@ -94,7 +95,7 @@ int cerver_parse_request(const char* raw, size_t len, cerver_request_t* req) {
    * The caller must keep it alive for the request's lifetime.
    */
   char* buf = (char*)raw;
-  buf[len] = '\0'; /* caller ensures buf has capacity for len+1 */
+  buf[len]  = '\0'; /* caller ensures buf has capacity for len+1 */
 
   /* We no longer allocate _raw_buf — the read buffer IS the raw buffer */
   req->_raw_buf = NULL;
@@ -117,7 +118,7 @@ int cerver_parse_request(const char* raw, size_t len, cerver_request_t* req) {
 
   /* Path (and maybe query string) */
   char* path_start = sp1 + 1;
-  char* sp2 = strchr(path_start, ' ');
+  char* sp2        = strchr(path_start, ' ');
   if (sp2) *sp2 = '\0';
 
   /* Split path and query string */
@@ -125,8 +126,8 @@ int cerver_parse_request(const char* raw, size_t len, cerver_request_t* req) {
   if (qmark) {
     *qmark = '\0';
     /* Point query_string directly into the buffer */
-    char* qs_start = qmark + 1;
-    size_t qs_len = strlen(qs_start);
+    char*  qs_start = qmark + 1;
+    size_t qs_len   = strlen(qs_start);
     if (qs_len >= sizeof(req->query_string)) qs_len = sizeof(req->query_string) - 1;
     memcpy(req->query_string, qs_start, qs_len);
     req->query_string[qs_len] = '\0';
@@ -148,7 +149,7 @@ int cerver_parse_request(const char* raw, size_t len, cerver_request_t* req) {
   }
 
   /* ---- Headers ---- */
-  char* hdr_start = line_end + 2; /* skip \r\n */
+  char*  hdr_start      = line_end + 2; /* skip \r\n */
   size_t content_length = 0;
 
   while (hdr_start < buf + len) {
@@ -166,11 +167,11 @@ int cerver_parse_request(const char* raw, size_t len, cerver_request_t* req) {
     if (req->header_count < CERVER_MAX_HEADERS) {
       char* colon = strchr(hdr_start, ':');
       if (colon) {
-        *colon = '\0';
+        *colon    = '\0';
         char* val = colon + 1;
         while (*val == ' ') val++;
 
-        req->headers[req->header_count].key = hdr_start;
+        req->headers[req->header_count].key   = hdr_start;
         req->headers[req->header_count].value = val;
         req->header_count++;
 
@@ -186,7 +187,7 @@ int cerver_parse_request(const char* raw, size_t len, cerver_request_t* req) {
 
   /* ---- Body (for POST etc.) ---- */
   if (content_length > 0 && hdr_start < buf + len) {
-    req->body = hdr_start;
+    req->body     = hdr_start;
     req->body_len = content_length;
     /* Ensure we don't read past the buffer */
     size_t remaining = (size_t)(buf + len - hdr_start);

package/runtime/http_writer.c

@@ -12,6 +12,64 @@
 #include <string.h>
 #include <unistd.h>
 #include <sys/uio.h>
+#include <errno.h>
+
+#ifdef __linux__
+#include <sys/sendfile.h>
+static ssize_t cerver_sendfile(int out_fd, int in_fd, off_t offset, size_t count) {
+  off_t off = offset;
+  return sendfile(out_fd, in_fd, &off, count);
+}
+#elif defined(__APPLE__)
+#include <sys/types.h>
+#include <sys/socket.h>
+static ssize_t cerver_sendfile(int out_fd, int in_fd, off_t offset, size_t count) {
+  off_t len = (off_t)count;
+  int res = sendfile(in_fd, out_fd, offset, &len, NULL, 0);
+  if (res == 0) {
+    return (ssize_t)len;
+  }
+  if (len > 0) {
+    return (ssize_t)len;
+  }
+  /* Fallback to read-write copy if not a socket or unsupported on this descriptor type */
+  char buf[8192];
+  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);
+  if (n_read <= 0) return n_read;
+
+  size_t written = 0;
+  while (written < (size_t)n_read) {
+    ssize_t n_write = write(out_fd, buf + written, (size_t)n_read - written);
+    if (n_write < 0) {
+      if (errno == EINTR) continue;
+      return -1;
+    }
+    written += (size_t)n_write;
+  }
+  return (ssize_t)written;
+}
+#else
+static ssize_t cerver_sendfile(int out_fd, int in_fd, off_t offset, size_t count) {
+  char buf[8192];
+  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);
+  if (n_read <= 0) return n_read;
+
+  size_t written = 0;
+  while (written < (size_t)n_read) {
+    ssize_t n_write = write(out_fd, buf + written, (size_t)n_read - written);
+    if (n_write < 0) {
+      if (errno == EINTR) continue;
+      return -1;
+    }
+    written += (size_t)n_write;
+  }
+  return (ssize_t)written;
+}
+#endif
 
 /* ------------------------------------------------------------------ */
 /*  Status text lookup                                                */
@@ -57,7 +115,7 @@ static const char* status_text(int code) {
 int cerver_write_response(int fd, const cerver_response_t* res, int keepalive) {
   /* Build the response header */
   char header[4096];
-  int hlen = 0;
+  int  hlen = 0;
 
   /* Status line */
   hlen += snprintf(header + hlen, sizeof(header) - (size_t)hlen, "HTTP/1.1 %d %s\r\n", res->status,
@@ -93,40 +151,89 @@ int cerver_write_response(int fd, const cerver_response_t* res, int keepalive) {
   hlen += snprintf(header + hlen, sizeof(header) - (size_t)hlen, "\r\n");
 
   /*
-   * Use writev() to send header + body in a single syscall.
-   * This avoids Nagle interaction and reduces context switches.
+   * Use writev() or sendfile() to send response, or copy to contiguous
+   * buffer if body is small to avoid writev round-trips.
    */
-  if (res->body && res->body_len > 0) {
-    struct iovec iov[2];
-    iov[0].iov_base = header;
-    iov[0].iov_len = (size_t)hlen;
-    iov[1].iov_base = (void*)res->body;
-    iov[1].iov_len = res->body_len;
-
-    size_t total = iov[0].iov_len + iov[1].iov_len;
-    size_t written = 0;
+  if (res->_body_owned == 3) {
+    /* Send header first */
+    size_t header_total = (size_t)hlen;
+    size_t header_written = 0;
+    while (header_written < header_total) {
+      ssize_t n = write(fd, header + header_written, header_total - header_written);
+      if (n < 0) {
+        if (errno == EINTR) continue;
+        return -1;
+      }
+      header_written += (size_t)n;
+    }
 
-    while (written < total) {
-      ssize_t n = writev(fd, iov, 2);
-      if (n < 0) return -1;
-      written += (size_t)n;
+    /* Zero-copy body sending via sendfile(2) */
+    size_t body_total = res->body_len;
+    size_t body_sent = 0;
+    while (body_sent < body_total) {
+      ssize_t n = cerver_sendfile(fd, res->_file_fd, (off_t)body_sent, body_total - body_sent);
+      if (n < 0) {
+        if (errno == EINTR) continue;
+        return -1;
+      }
+      if (n == 0) break; /* EOF */
+      body_sent += (size_t)n;
+    }
+  } else if (res->body && res->body_len > 0) {
+    if ((size_t)hlen + res->body_len <= sizeof(header)) {
+      /* Small response optimization: copy body into header buffer and send in one syscall */
+      memcpy(header + hlen, res->body, res->body_len);
+      size_t total = (size_t)hlen + res->body_len;
+      size_t written = 0;
+      while (written < total) {
+        ssize_t n = write(fd, header + written, total - written);
+        if (n < 0) {
+          if (errno == EINTR) continue;
+          return -1;
+        }
+        written += (size_t)n;
+      }
+    } else {
+      /* Large response: use writev to send header + body */
+      struct iovec iov[2];
+      iov[0].iov_base = header;
+      iov[0].iov_len  = (size_t)hlen;
+      iov[1].iov_base = (void*)res->body;
+      iov[1].iov_len  = res->body_len;
+
+      size_t total   = iov[0].iov_len + iov[1].iov_len;
+      size_t written = 0;
 
-      /* Adjust iov for partial writes */
-      if (written < iov[0].iov_len) {
-        iov[0].iov_base = header + written;
-        iov[0].iov_len -= (size_t)n;
-      } else {
-        /* Header fully sent, adjust body iov */
-        size_t body_sent = written - (size_t)hlen;
-        iov[0].iov_len = 0;
-        iov[1].iov_base = (void*)(res->body + body_sent);
-        iov[1].iov_len = res->body_len - body_sent;
+      while (written < total) {
+        ssize_t n = writev(fd, iov, 2);
+        if (n < 0) return -1;
+        written += (size_t)n;
+
+        /* Adjust iov for partial writes */
+        size_t to_consume = (size_t)n;
+        if (to_consume < iov[0].iov_len) {
+          iov[0].iov_base = (char*)iov[0].iov_base + to_consume;
+          iov[0].iov_len -= to_consume;
+        } else {
+          to_consume -= iov[0].iov_len;
+          iov[0].iov_len  = 0;
+          iov[1].iov_base = (char*)iov[1].iov_base + to_consume;
+          iov[1].iov_len -= to_consume;
+        }
       }
     }
   } else {
     /* No body — just send header */
-    ssize_t written = write(fd, header, (size_t)hlen);
-    if (written < 0) return -1;
+    size_t total   = (size_t)hlen;
+    size_t written = 0;
+    while (written < total) {
+      ssize_t n = write(fd, header + written, total - written);
+      if (n < 0) {
+        if (errno == EINTR) continue;
+        return -1;
+      }
+      written += (size_t)n;
+    }
   }
 
   return 0;
@@ -137,41 +244,41 @@ int cerver_write_response(int fd, const cerver_response_t* res, int keepalive) {
 /* ------------------------------------------------------------------ */
 
 void cerver_res_text(cerver_response_t* res, int status, const char* text) {
-  res->status = status;
+  res->status       = status;
   res->content_type = "text/plain; charset=utf-8";
-  res->body = text;
-  res->body_len = strlen(text);
-  res->_body_owned = 0;
+  res->body         = text;
+  res->body_len     = strlen(text);
+  res->_body_owned  = 0;
 }
 
 void cerver_res_json(cerver_response_t* res, int status, const char* json) {
-  res->status = status;
+  res->status       = status;
   res->content_type = "application/json; charset=utf-8";
-  res->body = json;
-  res->body_len = strlen(json);
-  res->_body_owned = 0;
+  res->body         = json;
+  res->body_len     = strlen(json);
+  res->_body_owned  = 0;
 }
 
 void cerver_res_html(cerver_response_t* res, int status, const char* html) {
-  res->status = status;
+  res->status       = status;
   res->content_type = "text/html; charset=utf-8";
-  res->body = html;
-  res->body_len = strlen(html);
-  res->_body_owned = 0;
+  res->body         = html;
+  res->body_len     = strlen(html);
+  res->_body_owned  = 0;
 }
 
 void cerver_res_file(cerver_response_t* res, int status, const char* mime,
                      const unsigned char* data, size_t len) {
-  res->status = status;
+  res->status       = status;
   res->content_type = mime;
-  res->body = (const char*)data;
-  res->body_len = len;
-  res->_body_owned = 0;
+  res->body         = (const char*)data;
+  res->body_len     = len;
+  res->_body_owned  = 0;
 }
 
 void cerver_res_header(cerver_response_t* res, const char* key, const char* val) {
   if (res->header_count < CERVER_MAX_HEADERS) {
-    res->headers[res->header_count].key = key;
+    res->headers[res->header_count].key   = key;
     res->headers[res->header_count].value = val;
     res->header_count++;
   }

package/runtime/mime.c

@@ -5,6 +5,7 @@
 #include "cerver.h"
 
 #include <string.h>
+#include <strings.h>
 #include <ctype.h>
 
 typedef struct {