@velox0/cerver 0.4.2 → 0.4.3

package/README.md

@@ -1,9 +1,11 @@
-<div align="center">
-  <img src="templates/cerver.png" alt="Cerver Logo" width="120" />
-</div>
-
 # Cerver
 
+[![Publish](https://github.com/velox0/cerver/actions/workflows/publish.yml/badge.svg)](https://github.com/velox0/cerver/actions/workflows/publish.yml)
+[![CI](https://github.com/velox0/cerver/actions/workflows/ci.yml/badge.svg)](https://github.com/velox0/cerver/actions/workflows/ci.yml)
+[![npm](https://img.shields.io/npm/v/@velox0/cerver)](https://www.npmjs.com/package/@velox0/cerver)
+
+<img src="templates/cerver.png" alt="Cerver Logo" width="200px" align="right" />
+
 A lightweight, compile-time web framework that transpiles restricted JavaScript server logic into highly optimized native C HTTP server binaries.
 
 Cerver takes a Next.js-style file-based routing structure (written in a strict subset of JavaScript), parses it, generates equivalent C code, embeds your static assets, and compiles it all into a single, standalone executable that runs with zero Node.js dependency.
@@ -11,11 +13,26 @@ Cerver takes a Next.js-style file-based routing structure (written in a strict s
 ## Features
 
 - **Compile-Time Framework**: Your JavaScript is parsed and compiled to native C. There is no JavaScript engine (like V8) or interpreter included in the final binary.
-- **Microscopic Footprint**: Generated executables are typically ~50KB and start in milliseconds.
+- **Microscopic Footprint**: Generated executables are tiny and start in milliseconds.
 - **Single-Binary Deployment**: Static assets (HTML, CSS, JS, images) are automatically minified and embedded directly into the executable as C byte arrays.
 - **Native Performance**: Uses `kqueue` (macOS) or `epoll` (Linux) event loops for high-performance non-blocking I/O.
 - **File-Based Routing**: Intuitive `app/routes/` directory structure, supporting dynamic segments (e.g., `/item/[id].js`).
 
+## Benchmarks (Autocannon)
+
+Local loopback runs against `localhost`, 20s per run.
+
+Note: timeouts only appear at the highest concurrency (240 connections). On a single machine, autocannon and the server compete for CPU and kernel resources; the timeouts are likely client/loopback saturation rather than server errors.
+
+| Connections | Pipelining | Avg req/s | Avg latency | p99 latency | Total read | Errors (timeouts) |
+| ----------- | ---------- | --------- | ----------- | ----------- | ---------- | ----------------- |
+| 60          | 1          | 123,005   | 0.01 ms     | 0 ms        | 21.0 GB    | 0                 |
+| 60          | 10         | 125,973   | 4.26 ms     | 10 ms       | 21.5 GB    | 0                 |
+| 120         | 1          | 124,214   | 0.15 ms     | 1 ms        | 21.2 GB    | 0                 |
+| 120         | 10         | 131,245   | 8.64 ms     | 15 ms       | 22.4 GB    | 0                 |
+| 240         | 1          | 124,890   | 0.54 ms     | 1 ms        | 21.3 GB    | 118 (timeout)     |
+| 240         | 10         | 123,677   | 9.87 ms     | 14 ms       | 21.1 GB    | 1540 (timeout)    |
+
 ## Getting Started
 
 1. Install globally (requires `gcc` or `clang` on your system):

package/lib/codegen/dispatch_gen.js

@@ -162,6 +162,9 @@ function generateDispatch(routes) {
             lines.push(
               `                req->params[req->params_count].value = seg${i}_start;`
             );
+            lines.push(
+              `                ((char*)seg${i}_start)[seg${i}_len] = '\\0';`
+            );
             lines.push(`                req->params_count++;`);
             paramIdx++;
           }

package/package.json

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

package/runtime/cerver.h

@@ -119,6 +119,9 @@ typedef struct {
 
   /* 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 */
@@ -233,6 +236,9 @@ struct cerver_server {
   /* Worker pool */
   int              worker_count;
   cerver_worker_t* workers;
+
+  /* Route trie for radix/trie-based routing */
+  void*            route_trie;
 };
 
 /* Server lifecycle */
@@ -262,6 +268,9 @@ int cerver_write_response(int fd, const cerver_response_t* res, int keepalive);
 
 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)                                                   */

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                                                */
@@ -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;

package/runtime/router.c

@@ -19,8 +19,15 @@
 
 const char* cerver_req_param(const cerver_request_t* req, const char* key) {
   for (int i = 0; i < req->params_count; i++) {
-    if (strcmp(req->params[i].key, key) == 0) {
-      return req->params[i].value;
+    const char* pkey = req->params[i].key;
+    if (pkey && pkey[0] == key[0]) {
+      int j = 0;
+      while (key[j] && pkey[j] == key[j]) {
+        j++;
+      }
+      if (key[j] == '\0' && (pkey[j] == '\0' || pkey[j] == '/')) {
+        return req->params[i].value;
+      }
     }
   }
   return "";
@@ -102,6 +109,8 @@ int cerver_route_match(const cerver_route_t* route, cerver_request_t* req) {
   const char* rp = path;    /* request path pointer */
 
   int saved_params = req->params_count;
+  char* param_slashes[CERVER_MAX_PARAMS];
+  int param_slash_count = 0;
 
   /* Skip leading '/' */
   if (*pp == '/') pp++;
@@ -122,10 +131,12 @@ int cerver_route_match(const cerver_route_t* route, cerver_request_t* req) {
       /* Dynamic segment — extract parameter */
       if (req->params_count < CERVER_MAX_PARAMS) {
         req->params[req->params_count].key = pp_seg + 1;
-        /* Temporarily NUL-terminate the key at the slash */
-        /* The key points into the route pattern (static/const) */
+        /* The key points into the route pattern (static/const, not NUL-terminated) */
         req->params[req->params_count].value = rp_seg;
         req->params_count++;
+        if (*rp == '/') {
+          param_slashes[param_slash_count++] = (char*)rp;
+        }
       }
     } else {
       /* Static segment — must match exactly */
@@ -146,6 +157,11 @@ int cerver_route_match(const cerver_route_t* route, cerver_request_t* req) {
     return 0;
   }
 
+  /* Match succeeded, NUL-terminate extracted values in-place inside req->path */
+  for (int i = 0; i < param_slash_count; i++) {
+    *param_slashes[i] = '\0';
+  }
+
   return 1;
 }
 
@@ -153,6 +169,166 @@ int cerver_route_match(const cerver_route_t* route, cerver_request_t* req) {
 /*  Dispatch: find and return the handler for a request               */
 /* ------------------------------------------------------------------ */
 
+/* ------------------------------------------------------------------ */
+/*  Trie/Radix Route Router                                           */
+/* ------------------------------------------------------------------ */
+
+static char* trie_strndup(const char* s, size_t n) {
+  char* p = malloc(n + 1);
+  if (p) {
+    memcpy(p, s, n);
+    p[n] = '\0';
+  }
+  return p;
+}
+
+typedef struct trie_node trie_node_t;
+
+struct trie_node {
+  char* segment;
+  int is_param;
+  char* param_name;
+
+  struct {
+    const char* method;
+    cerver_handler_fn handler;
+  } handlers[16];
+  int handler_count;
+
+  trie_node_t** children;
+  int children_count;
+  int children_cap;
+};
+
+void* cerver_trie_create(void) {
+  trie_node_t* node = calloc(1, sizeof(trie_node_t));
+  return node;
+}
+
+static trie_node_t* trie_create_node(const char* segment, size_t len) {
+  trie_node_t* node = calloc(1, sizeof(trie_node_t));
+  if (node && segment) {
+    node->segment = trie_strndup(segment, len);
+    if (node->segment[0] == ':') {
+      node->is_param = 1;
+      node->param_name = trie_strndup(node->segment + 1, len - 1);
+    }
+  }
+  return node;
+}
+
+void cerver_trie_insert(void* trie, const char* pattern, const char* method, cerver_handler_fn handler) {
+  if (!trie) return;
+  trie_node_t* curr = (trie_node_t*)trie;
+  const char* p = pattern;
+  while (*p == '/') p++;
+
+  while (*p) {
+    const char* seg_start = p;
+    while (*p && *p != '/') p++;
+    size_t len = (size_t)(p - seg_start);
+    if (len == 0) {
+      while (*p == '/') p++;
+      continue;
+    }
+
+    // Find if child exists
+    trie_node_t* child = NULL;
+    for (int i = 0; i < curr->children_count; i++) {
+      trie_node_t* c = curr->children[i];
+      if (strlen(c->segment) == len && memcmp(c->segment, seg_start, len) == 0) {
+        child = c;
+        break;
+      }
+    }
+
+    if (!child) {
+      child = trie_create_node(seg_start, len);
+      if (curr->children_count >= curr->children_cap) {
+        curr->children_cap = curr->children_cap == 0 ? 4 : curr->children_cap * 2;
+        curr->children = realloc(curr->children, curr->children_cap * sizeof(trie_node_t*));
+      }
+      curr->children[curr->children_count++] = child;
+    }
+
+    curr = child;
+    while (*p == '/') p++;
+  }
+
+  // Add handler to leaf
+  if (curr->handler_count < 16) {
+    curr->handlers[curr->handler_count].method = method;
+    curr->handlers[curr->handler_count].handler = handler;
+    curr->handler_count++;
+  }
+}
+
+void cerver_trie_free(void* trie) {
+  if (!trie) return;
+  trie_node_t* node = (trie_node_t*)trie;
+  for (int i = 0; i < node->children_count; i++) {
+    cerver_trie_free(node->children[i]);
+  }
+  free(node->children);
+  free(node->segment);
+  free(node->param_name);
+  free(node);
+}
+
+static int trie_match_recursive(trie_node_t* node, const char* path, cerver_request_t* req, cerver_handler_fn* out_handler, int param_start_idx) {
+  // Skip leading slashes
+  while (*path == '/') path++;
+
+  if (*path == '\0') {
+    // Check if node has a handler for req->method
+    for (int i = 0; i < node->handler_count; i++) {
+      if (strcmp(node->handlers[i].method, req->method) == 0) {
+        *out_handler = node->handlers[i].handler;
+        req->params_count = param_start_idx;
+        return 1;
+      }
+    }
+    return 0;
+  }
+
+  // Extract next segment from path
+  const char* seg_start = path;
+  while (*path && *path != '/') path++;
+  size_t seg_len = (size_t)(path - seg_start);
+
+  // Try static children first
+  for (int i = 0; i < node->children_count; i++) {
+    trie_node_t* child = node->children[i];
+    if (!child->is_param) {
+      if (strlen(child->segment) == seg_len && memcmp(child->segment, seg_start, seg_len) == 0) {
+        if (trie_match_recursive(child, path, req, out_handler, param_start_idx)) {
+          return 1;
+        }
+      }
+    }
+  }
+
+  // Try parameter/dynamic children next
+  for (int i = 0; i < node->children_count; i++) {
+    trie_node_t* child = node->children[i];
+    if (child->is_param) {
+      if (param_start_idx < CERVER_MAX_PARAMS) {
+        req->params[param_start_idx].key = child->param_name;
+        req->params[param_start_idx].value = seg_start;
+      }
+      if (trie_match_recursive(child, path, req, out_handler, param_start_idx + 1)) {
+        return 1;
+      }
+    }
+  }
+
+  return 0;
+}
+
+/* ------------------------------------------------------------------ */
+/*  Dispatch: find and return the handler for a request               */
+/* ------------------------------------------------------------------ */
+
 cerver_handler_fn cerver_dispatch(cerver_server_t* srv, cerver_request_t* req) {
   /* Try the generated compile-time dispatch first */
   if (srv->dispatch_override) {
@@ -160,13 +336,19 @@ cerver_handler_fn cerver_dispatch(cerver_server_t* srv, cerver_request_t* req) {
     if (h) return h;
   }
 
-  /* Fall back to generic route table scan */
-  if (!srv->routes) return NULL;
+  /* Fall back to generic route table scan via Trie */
+  if (!srv->route_trie) return NULL;
 
-  for (int i = 0; i < srv->route_count; i++) {
-    if (cerver_route_match(&srv->routes[i], req)) {
-      return srv->routes[i].handler;
+  cerver_handler_fn handler = NULL;
+  req->params_count = 0;
+  if (trie_match_recursive((trie_node_t*)srv->route_trie, req->path, req, &handler, 0)) {
+    // NUL-terminate extracted values in-place inside req->path
+    for (int i = 0; i < req->params_count; i++) {
+      char* val = (char*)req->params[i].value;
+      while (*val && *val != '/') val++;
+      if (*val == '/') *val = '\0';
     }
+    return handler;
   }
 
   return NULL;

package/runtime/server.c

@@ -278,6 +278,8 @@ static void handle_connection(cerver_server_t* srv, int client_fd) {
       free((void*)res.body);
     else if (res._body_owned == 2 && res.body)
       munmap((void*)res.body, res.body_len);
+    else if (res._body_owned == 3 && res._file_fd >= 0)
+      close(res._file_fd);
 
     free(buf);
     if (write_err < 0) break;
@@ -348,7 +350,7 @@ static int create_listener(int port, int reuseport) {
   int opt = 1;
   setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
 
-#ifdef __linux__
+#if defined(__linux__) || defined(__APPLE__) || defined(__FreeBSD__)
   if (reuseport) setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &opt, sizeof(opt));
 #else
   (void)reuseport;
@@ -621,6 +623,13 @@ 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) {
   srv->routes      = routes;
   srv->route_count = count;
+
+  srv->route_trie = cerver_trie_create();
+  if (srv->route_trie) {
+    for (int i = 0; i < count; i++) {
+      cerver_trie_insert(srv->route_trie, routes[i].pattern, routes[i].method, routes[i].handler);
+    }
+  }
   return 0;
 }
 
@@ -702,7 +711,7 @@ int cerver_listen(cerver_server_t* srv) {
     return -1;
   }
 
-  srv->sock_fd = create_listener(srv->port, 0);
+  srv->sock_fd = create_listener(srv->port, 1);
   if (srv->sock_fd < 0) {
     srv->running = 0;
     for (int i = 0; i < pool_size; i++) pthread_join(pool_threads[i], NULL);
@@ -730,9 +739,13 @@ int cerver_listen(cerver_server_t* srv) {
     w->id              = i;
     w->srv             = srv;
     w->event_fd        = -1;
-#ifdef __linux__
-    w->listen_fd = create_listener(srv->port, 1);
-    if (w->listen_fd < 0) w->listen_fd = srv->sock_fd;
+#if defined(__linux__) || defined(__APPLE__) || defined(__FreeBSD__)
+    if (i == 0) {
+      w->listen_fd = srv->sock_fd;
+    } else {
+      w->listen_fd = create_listener(srv->port, 1);
+      if (w->listen_fd < 0) w->listen_fd = srv->sock_fd;
+    }
 #else
     w->listen_fd = srv->sock_fd;
 #endif
@@ -791,7 +804,7 @@ void cerver_shutdown(cerver_server_t* srv) {
 
   if (srv->workers) {
     for (int i = 0; i < srv->worker_count; i++) {
-#ifdef __linux__
+#if defined(__linux__) || defined(__APPLE__) || defined(__FreeBSD__)
       if (srv->workers[i].listen_fd != srv->sock_fd && srv->workers[i].listen_fd >= 0)
         close(srv->workers[i].listen_fd);
 #endif
@@ -801,6 +814,11 @@ void cerver_shutdown(cerver_server_t* srv) {
     srv->workers = NULL;
   }
 
+  if (srv->route_trie) {
+    cerver_trie_free(srv->route_trie);
+    srv->route_trie = NULL;
+  }
+
   if (srv->sock_fd >= 0) {
     close(srv->sock_fd);
     srv->sock_fd = -1;

package/runtime/static.c

@@ -189,59 +189,19 @@ static int serve_filesystem(cerver_server_t* srv, cerver_request_t* req, cerver_
   const char* mime = cerver_mime_from_path(full_path);
 
   /*
-   * Use mmap for zero-copy serving instead of fopen+malloc+fread.
-   * The mmap'd region is used directly as the response body.
-   * We mark it as _body_owned=0 since munmap needs special handling,
-   * but for simplicity we'll use read() for small files and mmap for large.
+   * Use sendfile for zero-copy filesystem static serving.
+   * The file is opened and its descriptor is stored in the response structure
+   * for streaming directly to the client socket in the writer.
    */
-  if (file_size > 65536) {
-    /* Large files: mmap for zero-copy */
-    int fd = open(full_path, O_RDONLY);
-    if (fd < 0) return -1;
-
-    void* mapped = mmap(NULL, file_size, PROT_READ, MAP_PRIVATE, fd, 0);
-    close(fd);
-
-    if (mapped == MAP_FAILED) return -1;
-
-    /* Advise the kernel we'll read sequentially */
-    madvise(mapped, file_size, MADV_SEQUENTIAL);
-
-    res->status       = 200;
-    res->content_type = mime;
-    res->body         = (const char*)mapped;
-    res->body_len     = file_size;
-    res->_body_owned  = 2; /* Special flag: needs munmap, not free */
-  } else {
-    /* Small files: read into buffer (avoids mmap overhead) */
-    int fd = open(full_path, O_RDONLY);
-    if (fd < 0) return -1;
-
-    char* file_data = malloc(file_size);
-    if (!file_data) {
-      close(fd);
-      return -1;
-    }
-
-    size_t total = 0;
-    while (total < file_size) {
-      ssize_t n = read(fd, file_data + total, file_size - total);
-      if (n <= 0) break;
-      total += (size_t)n;
-    }
-    close(fd);
-
-    if (total != file_size) {
-      free(file_data);
-      return -1;
-    }
-
-    res->status       = 200;
-    res->content_type = mime;
-    res->body         = file_data;
-    res->body_len     = file_size;
-    res->_body_owned  = 1; /* malloc'd */
-  }
+  int fd = open(full_path, O_RDONLY);
+  if (fd < 0) return -1;
+
+  res->status       = 200;
+  res->content_type = mime;
+  res->body         = NULL;
+  res->body_len     = file_size;
+  res->_body_owned  = 3; /* Special flag: sendfile, close fd */
+  res->_file_fd     = fd;
 
   add_cache_headers(res, path);
 

package/runtime/tests/runtime_tests.c

@@ -224,6 +224,22 @@ static void test_route_match_mismatch_resets_params(void) {
   MU_ASSERT_EQ_INT(0, req.params_count);
 }
 
+static void test_route_match_multi_segment(void) {
+  cerver_route_t route;
+  route.method  = "GET";
+  route.pattern = "/users/:id/profile";
+  route.handler = handler_a;
+
+  cerver_request_t req;
+  memset(&req, 0, sizeof(req));
+  strcpy(req.method, "GET");
+  strcpy(req.path, "/users/123/profile");
+
+  MU_ASSERT(cerver_route_match(&route, &req) == 1);
+  MU_ASSERT_EQ_INT(1, req.params_count);
+  MU_ASSERT_STREQ("123", cerver_req_param(&req, "id"));
+}
+
 static void test_request_header_helpers(void) {
   cerver_request_t req;
   memset(&req, 0, sizeof(req));
@@ -318,10 +334,27 @@ static void test_static_filesystem_small(void) {
 
   MU_ASSERT_EQ_INT(0, cerver_serve_static(&srv, &req, &res));
   MU_ASSERT_EQ_SIZE(5, res.body_len);
-  MU_ASSERT(memcmp(res.body, "small", 5) == 0);
-  MU_ASSERT_EQ_INT(1, res._body_owned);
+  MU_ASSERT(res.body == NULL);
+  MU_ASSERT_EQ_INT(3, res._body_owned);
+  MU_ASSERT(res._file_fd >= 0);
+
+  int fds[2];
+  MU_ASSERT(pipe(fds) == 0);
+  MU_ASSERT_EQ_INT(0, cerver_write_response(fds[1], &res, 1));
+  close(fds[1]);
 
-  free((void*)res.body);
+  char out[1024];
+  ssize_t n = read_all(fds[0], out, sizeof(out));
+  MU_ASSERT(n > 0);
+  close(fds[0]);
+
+  MU_ASSERT(strstr(out, "HTTP/1.1 200 OK\r\n") != NULL);
+  MU_ASSERT(strstr(out, "Content-Length: 5\r\n") != NULL);
+  MU_ASSERT(strstr(out, "\r\nsmall") != NULL);
+
+  if (res._body_owned == 3 && res._file_fd >= 0) {
+    close(res._file_fd);
+  }
   unlink(file_path);
   rmdir(dir);
 }
@@ -334,10 +367,10 @@ static void test_static_filesystem_large(void) {
   char file_path[PATH_MAX];
   snprintf(file_path, sizeof(file_path), "%s/large.bin", dir);
 
-  char* payload = (char*)malloc(70000);
+  char* payload = (char*)malloc(32000);
   MU_ASSERT(payload != NULL);
-  memset(payload, 'a', 70000);
-  MU_ASSERT_EQ_INT(0, write_file(file_path, payload, 70000));
+  memset(payload, 'a', 32000);
+  MU_ASSERT_EQ_INT(0, write_file(file_path, payload, 32000));
   free(payload);
 
   cerver_server_t srv;
@@ -352,11 +385,27 @@ static void test_static_filesystem_large(void) {
   strcpy(req.path, "/large.bin");
 
   MU_ASSERT_EQ_INT(0, cerver_serve_static(&srv, &req, &res));
-  MU_ASSERT_EQ_SIZE(70000, res.body_len);
-  MU_ASSERT_EQ_INT(2, res._body_owned);
-  MU_ASSERT(((const char*)res.body)[0] == 'a');
+  MU_ASSERT_EQ_SIZE(32000, res.body_len);
+  MU_ASSERT(res.body == NULL);
+  MU_ASSERT_EQ_INT(3, res._body_owned);
+  MU_ASSERT(res._file_fd >= 0);
 
-  munmap((void*)res.body, res.body_len);
+  int fds[2];
+  MU_ASSERT(pipe(fds) == 0);
+  MU_ASSERT_EQ_INT(0, cerver_write_response(fds[1], &res, 1));
+  close(fds[1]);
+
+  char out[35000];
+  ssize_t n = read_all(fds[0], out, sizeof(out));
+  MU_ASSERT(n > 0);
+  close(fds[0]);
+
+  MU_ASSERT(strstr(out, "HTTP/1.1 200 OK\r\n") != NULL);
+  MU_ASSERT(strstr(out, "Content-Length: 32000\r\n") != NULL);
+
+  if (res._body_owned == 3 && res._file_fd >= 0) {
+    close(res._file_fd);
+  }
   unlink(file_path);
   rmdir(dir);
 }
@@ -402,6 +451,7 @@ int main(void) {
   mu_run("write_response_force_close", test_write_response_force_close);
   mu_run("route_match_and_dispatch", test_route_match_and_dispatch);
   mu_run("route_match_mismatch_resets_params", test_route_match_mismatch_resets_params);
+  mu_run("route_match_multi_segment", test_route_match_multi_segment);
   mu_run("request_header_helpers", test_request_header_helpers);
   mu_run("static_embedded_prefers_br", test_static_embedded_prefers_br);
   mu_run("static_embedded_index_fallback", test_static_embedded_index_fallback);

package/test/run.js

@@ -190,6 +190,17 @@ test("generateRouteTable emits forward declarations, entries, and count", () =>
   assert.match(code, /static const int cerver_route_count = 2;/);
 });
 
+test("generateDispatch generates correct parameter extraction and termination", () => {
+  const { generateDispatch } = require("../lib/codegen/dispatch_gen");
+  const routes = [
+    IR.IRRoute("GET", "/users/:id/profile", ["id"], IR.IRHandler([], [])),
+  ];
+  const code = generateDispatch(routes);
+  assert.match(code, /req->params\[req->params_count\]\.key = "id";/);
+  assert.match(code, /req->params\[req->params_count\]\.value = seg1_start;/);
+  assert.match(code, /\(\(char\*\)seg1_start\)\[seg1_len\] = '\\0';/);
+});
+
 test("loadConfig merges defaults and supports export default configs", () => {
   const dir = tempDir();
   try {