@velox0/cerver 0.3.1 → 0.4.0

package/.github/workflows/publish.yml

@@ -18,18 +18,18 @@ jobs:
 
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
 
       - name: Setup pnpm
-        uses: pnpm/action-setup@v4
+        uses: pnpm/action-setup@v6
         with:
           version: 10
           run_install: false
 
       - name: Setup Node.js
-        uses: actions/setup-node@v4
+        uses: actions/setup-node@v6
         with:
-          node-version: 20
+          node-version: 24
           registry-url: https://registry.npmjs.org
           cache: pnpm
 

package/lib/assets/embed.js

@@ -179,7 +179,8 @@ async function generateEmbeddedAssets(assets, shouldMinify, compression) {
       `    { "${entry.servePath}", "${entry.mime}", ` +
         `${entry.name}, ${entry.name}_len, ` +
         `${entry.gzName}, ${entry.gzLen}, ` +
-        `${entry.brName}, ${entry.brLen} },`
+        `${entry.brName}, ${entry.brLen}, ` +
+        `NULL, 0 },`
     );
   }
   lines.push("};");

package/lib/codegen/dispatch_gen.js

@@ -0,0 +1,189 @@
+"use strict";
+
+const { cString, handlerName } = require("./emit");
+
+/**
+ * Generate a compile-time dispatch function that avoids the generic router.
+ *
+ * For static routes: method check → length check → memcmp (known lengths).
+ * For dynamic routes: segment-count check → per-segment inline comparisons.
+ *
+ * Falls through to generic router for unmatched paths.
+ *
+ * @param {IRRoute[]} routes - All IR routes
+ * @returns {string} - C source for cerver_generated_dispatch()
+ */
+function generateDispatch(routes) {
+  const lines = [];
+
+  /* Separate static and dynamic routes */
+  const staticRoutes = routes.filter((r) => !r.urlPath.includes(":"));
+  const dynamicRoutes = routes.filter((r) => r.urlPath.includes(":"));
+
+  /* Forward declarations for handler functions */
+  lines.push("/* ---- Generated Fast Dispatch ---- */");
+  lines.push("");
+
+  /* Group static routes by method */
+  const byMethod = {};
+  for (const route of staticRoutes) {
+    if (!byMethod[route.method]) byMethod[route.method] = [];
+    byMethod[route.method].push(route);
+  }
+
+  /* Group dynamic routes by method */
+  const dynByMethod = {};
+  for (const route of dynamicRoutes) {
+    if (!dynByMethod[route.method]) dynByMethod[route.method] = [];
+    dynByMethod[route.method].push(route);
+  }
+
+  /* Generate the dispatch function */
+  lines.push(
+    "static cerver_handler_fn cerver_generated_dispatch(cerver_request_t *req) {"
+  );
+  lines.push("    const char *path = req->path;");
+  lines.push("    size_t path_len = 0;");
+  lines.push("    { const char *p = path; while (*p) { path_len++; p++; } }");
+  lines.push("");
+
+  const allMethods = new Set([
+    ...Object.keys(byMethod),
+    ...Object.keys(dynByMethod),
+  ]);
+
+  let firstMethod = true;
+  for (const method of allMethods) {
+    const methodStatic = byMethod[method] || [];
+    const methodDynamic = dynByMethod[method] || [];
+
+    /* Method check */
+    const methodLen = method.length;
+    lines.push(
+      `    ${firstMethod ? "" : "} else "}if (req->method[0] == '${method[0]}' && memcmp(req->method, ${cString(method)}, ${methodLen + 1}) == 0) {`
+    );
+    firstMethod = false;
+
+    /* ---- Static routes: group by path length for fast rejection ---- */
+    if (methodStatic.length > 0) {
+      /* Group by length */
+      const byLength = {};
+      for (const route of methodStatic) {
+        const len = route.urlPath.length;
+        if (!byLength[len]) byLength[len] = [];
+        byLength[len].push(route);
+      }
+
+      lines.push("        /* Static routes */");
+
+      const lengths = Object.keys(byLength)
+        .map(Number)
+        .sort((a, b) => a - b);
+
+      for (const len of lengths) {
+        const routesAtLen = byLength[len];
+
+        lines.push(`        if (path_len == ${len}) {`);
+
+        for (const route of routesAtLen) {
+          const name = handlerName(route.method, route.urlPath);
+          if (route.urlPath === "/") {
+            lines.push(
+              `            if (path[0] == '/' && path[1] == '\\0') return ${name};`
+            );
+          } else {
+            lines.push(
+              `            if (memcmp(path, ${cString(route.urlPath)}, ${len}) == 0) return ${name};`
+            );
+          }
+        }
+
+        lines.push("        }");
+      }
+    }
+
+    /* ---- Dynamic routes: inline segment matching ---- */
+    if (methodDynamic.length > 0) {
+      lines.push("");
+      lines.push("        /* Dynamic routes */");
+
+      for (const route of methodDynamic) {
+        const segments = route.urlPath.split("/").filter(Boolean);
+        const name = handlerName(route.method, route.urlPath);
+
+        lines.push("        {");
+        lines.push(`            /* ${route.urlPath} */`);
+        lines.push(`            const char *p = path;`);
+        lines.push(`            if (*p == '/') p++;`);
+        lines.push(`            int match = 1;`);
+
+        for (let i = 0; i < segments.length; i++) {
+          const seg = segments[i];
+          const isLast = i === segments.length - 1;
+
+          if (seg.startsWith(":")) {
+            const paramName = seg.slice(1);
+            /* Dynamic segment: find the segment boundaries */
+            lines.push(`            const char *seg${i}_start = p;`);
+            lines.push(`            while (*p && *p != '/') p++;`);
+            lines.push(`            size_t seg${i}_len = (size_t)(p - seg${i}_start);`);
+            lines.push(`            if (seg${i}_len == 0) match = 0;`);
+
+            if (!isLast) {
+              lines.push(`            if (match && *p == '/') p++; else if (!${isLast}) match = 0;`);
+            }
+          } else {
+            /* Static segment: compare directly */
+            const segLen = seg.length;
+            lines.push(
+              `            if (match && memcmp(p, ${cString(seg)}, ${segLen}) == 0 && (p[${segLen}] == '/' || p[${segLen}] == '\\0')) {`
+            );
+            lines.push(`                p += ${segLen};`);
+            lines.push(`                if (*p == '/') p++;`);
+            lines.push(`            } else { match = 0; }`);
+          }
+        }
+
+        /* Ensure path is fully consumed */
+        lines.push(`            if (match && *p != '\\0') match = 0;`);
+
+        /* Extract params on match */
+        lines.push(`            if (match) {`);
+
+        /* Re-iterate to set params */
+        let paramIdx = 0;
+        for (let i = 0; i < segments.length; i++) {
+          const seg = segments[i];
+          if (seg.startsWith(":")) {
+            const paramName = seg.slice(1);
+            lines.push(
+              `                req->params[req->params_count].key = ${cString(paramName)};`
+            );
+            lines.push(
+              `                req->params[req->params_count].value = seg${i}_start;`
+            );
+            lines.push(`                req->params_count++;`);
+            paramIdx++;
+          }
+        }
+
+        lines.push(`                return ${name};`);
+        lines.push(`            }`);
+        lines.push(`        }`);
+      }
+    }
+  }
+
+  if (!firstMethod) {
+    lines.push("    }");
+  }
+
+  lines.push("");
+  lines.push("    return NULL; /* No match — fall through to generic router */");
+  lines.push("}");
+  lines.push("");
+
+  return lines.join("\n");
+}
+
+module.exports = { generateDispatch };

package/lib/codegen/generator.js

@@ -2,6 +2,7 @@
 
 const { handlerName, emitStatement } = require("./emit");
 const { generateRouteTable } = require("./route_table");
+const { generateDispatch } = require("./dispatch_gen");
 
 /**
  * Generate the complete C server source file from IR routes.
@@ -70,6 +71,11 @@ function generateServer(routes, config, assetsCode) {
     lines.push("");
   }
 
+  /* ---- Generated fast dispatch ---- */
+  lines.push("/* ---- Generated Fast Dispatch (compile-time optimized) ---- */");
+  lines.push("");
+  lines.push(generateDispatch(routes));
+
   /* ---- Main function ---- */
   lines.push("/* ---- Entry Point ---- */");
   lines.push("");
@@ -81,7 +87,7 @@ function generateServer(routes, config, assetsCode) {
   lines.push("");
   lines.push("    /* Allow PORT env override */");
   lines.push('    const char *env_port = getenv("CERVER_PORT");');
-  lines.push("    if (!env_port) env_port = getenv(\"PORT\");");
+  lines.push('    if (!env_port) env_port = getenv("PORT");');
   lines.push("    if (env_port) port = atoi(env_port);");
   lines.push("");
   lines.push("    cerver_server_t srv;");
@@ -92,6 +98,11 @@ function generateServer(routes, config, assetsCode) {
   );
   lines.push("");
 
+  /* Wire up generated dispatch */
+  lines.push("    /* Use generated compile-time dispatch for fast routing */");
+  lines.push("    cerver_set_dispatch(&srv, cerver_generated_dispatch);");
+  lines.push("");
+
   if (assetsCode) {
     lines.push(
       "    cerver_set_assets(&srv, cerver_embedded_assets, cerver_embedded_asset_count);"

package/lib/compiler/compile.js

@@ -22,6 +22,20 @@ function detectCompiler() {
   );
 }
 
+/**
+ * Check if a compiler supports a given flag.
+ */
+function supportsFlag(cc, flag) {
+  try {
+    execSync(`echo 'int main(){}' | ${cc} ${flag} -x c -o /dev/null - 2>/dev/null`, {
+      stdio: "ignore",
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 /**
  * Compile the generated C source into a binary.
  *
@@ -46,9 +60,9 @@ function compile(distDir, runtimeDir, opts) {
     .filter((f) => f.endsWith(".c"))
     .map((f) => path.join(runtimeDir, f));
 
-  /* Build the compiler command */
+  /* Build the compiler command with aggressive optimization */
   const args = [
-    "-O2",
+    "-O3",
     "-Wall",
     "-Wextra",
     "-Wno-unused-parameter",
@@ -60,10 +74,23 @@ function compile(distDir, runtimeDir, opts) {
     "-lpthread",
   ];
 
+  /* Add LTO if supported */
+  if (supportsFlag(cc, "-flto")) {
+    args.splice(1, 0, "-flto");
+  }
+
+  /* Add march=native if supported (for SIMD/hardware-specific opts) */
+  if (supportsFlag(cc, "-march=native")) {
+    args.push("-march=native");
+  }
+
   if (opts && opts.static) {
     args.push("-static");
   }
 
+  /* On macOS, we need to define _GNU_SOURCE for some functions */
+  args.push("-D_GNU_SOURCE");
+
   console.log(`  compiling with ${cc}...`);
   console.log(`  ${cc} ${args.join(" ")}`);
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@velox0/cerver",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "description": "Compile restricted JavaScript server logic into optimized native C binaries",
   "main": "lib/index.js",
   "bin": {

package/runtime/cerver.h

@@ -26,8 +26,21 @@
 #define CERVER_READ_BUF_MAX    (1 << 20)   /* 1 MB hard limit */
 #define CERVER_MAX_ROUTES      256
 
+/* Keep-alive settings */
+#define CERVER_KEEPALIVE_MAX     10000   /* max requests per connection */
+#define CERVER_KEEPALIVE_TIMEOUT 5     /* seconds idle between requests */
+
+/* Event loop tuning */
+#define CERVER_MAX_EVENTS      256
+#define CERVER_LISTEN_BACKLOG  4096
+
+/* Worker architecture */
 #define CERVER_THREAD_POOL_DEFAULT  4
-#define CERVER_TASK_QUEUE_SIZE      256
+#define CERVER_TASK_QUEUE_SIZE      1024
+
+/* Stat cache for filesystem serving */
+#define CERVER_STAT_CACHE_SIZE   256
+#define CERVER_STAT_CACHE_TTL    60    /* seconds */
 
 /* ------------------------------------------------------------------ */
 /*  Key-value pair (used for headers, query params, route params)     */
@@ -68,7 +81,7 @@ typedef struct {
     const char *body;
     size_t      body_len;
 
-    /* Internal: raw buffer ownership */
+    /* Internal: raw buffer ownership (NULL if in-place parsing used) */
     char       *_raw_buf;
     size_t      _raw_len;
 } cerver_request_t;
@@ -91,6 +104,9 @@ typedef struct {
 
     /* Internal flag: was body malloc'd? */
     int         _body_owned;
+
+    /* Keep-alive control: set to 1 to force close after response */
+    int         _force_close;
 } cerver_response_t;
 
 /* Response helpers — called by generated handler code */
@@ -109,6 +125,9 @@ const char *cerver_req_param(const cerver_request_t *req, const char *key);
 const char *cerver_req_query(const cerver_request_t *req, const char *key);
 const char *cerver_req_header(const cerver_request_t *req, const char *key);
 
+/* Check if client wants to close after this request */
+int cerver_req_wants_close(const cerver_request_t *req);
+
 /* ------------------------------------------------------------------ */
 /*  Route definition                                                  */
 /* ------------------------------------------------------------------ */
@@ -136,13 +155,54 @@ typedef struct {
     size_t               data_gz_len;
     const unsigned char *data_br;
     size_t               data_br_len;
+
+    /* Pre-computed response header (NULL if not generated) */
+    const char          *prebuilt_header;
+    size_t               prebuilt_header_len;
 } cerver_asset_t;
 
 /* ------------------------------------------------------------------ */
-/*  Server                                                            */
+/*  Stat cache for filesystem serving                                 */
+/* ------------------------------------------------------------------ */
+
+typedef struct {
+    char     path[CERVER_MAX_PATH];
+    size_t   file_size;
+    time_t   mtime;
+    time_t   cached_at;
+    int      valid;
+} cerver_stat_entry_t;
+
+typedef struct {
+    cerver_stat_entry_t entries[CERVER_STAT_CACHE_SIZE];
+    pthread_mutex_t     lock;
+} cerver_stat_cache_t;
+
+/* ------------------------------------------------------------------ */
+/*  Generated dispatch (compile-time route optimization)              */
+/* ------------------------------------------------------------------ */
+
+typedef cerver_handler_fn (*cerver_dispatch_fn)(cerver_request_t *req);
+
 /* ------------------------------------------------------------------ */
+/*  Worker state (per-core event loop)                                */
+/* ------------------------------------------------------------------ */
+
+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 */
+    cerver_server_t *srv;
+    pthread_t        thread;
+} cerver_worker_t;
+
+/* ------------------------------------------------------------------ */
+/*  Server                                                            */
+/* ------------------------------------------------------------------ */
+
+struct cerver_server {
     int              port;
     int              sock_fd;
     cerver_route_t  *routes;
@@ -152,22 +212,23 @@ typedef struct {
     const char      *public_dir;   /* NULL if embedded mode */
     volatile int     running;
 
-    /* Thread pool */
-    int              thread_count;
-    pthread_t       *threads;
-    int              task_queue[CERVER_TASK_QUEUE_SIZE];
-    int              tq_head;
-    int              tq_tail;
-    int              tq_count;
-    pthread_mutex_t  tq_mutex;
-    pthread_cond_t   tq_cond;
-} cerver_server_t;
+    /* Generated dispatch override (faster than generic router) */
+    cerver_dispatch_fn dispatch_override;
+
+    /* Stat cache for filesystem serving */
+    cerver_stat_cache_t stat_cache;
+
+    /* Worker pool */
+    int              worker_count;
+    cerver_worker_t *workers;
+};
 
 /* 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);
 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);
 void cerver_shutdown(cerver_server_t *srv);
 
@@ -181,7 +242,7 @@ int cerver_parse_request(const char *raw, size_t len, cerver_request_t *req);
 /*  HTTP writer (internal)                                            */
 /* ------------------------------------------------------------------ */
 
-int cerver_write_response(int fd, const cerver_response_t *res);
+int cerver_write_response(int fd, const cerver_response_t *res, int keepalive);
 
 /* ------------------------------------------------------------------ */
 /*  Router (internal)                                                 */
@@ -203,4 +264,14 @@ const char *cerver_mime_from_path(const char *path);
 int cerver_serve_static(cerver_server_t *srv, cerver_request_t *req,
                         cerver_response_t *res);
 
+/* ------------------------------------------------------------------ */
+/*  Stat cache (internal)                                             */
+/* ------------------------------------------------------------------ */
+
+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);
+void cerver_stat_cache_store(cerver_stat_cache_t *cache, const char *path,
+                             size_t file_size, time_t mtime);
+
 #endif /* CERVER_H */

package/runtime/http_parser.c

@@ -2,7 +2,8 @@
  * http_parser.c — Minimal HTTP/1.1 request parser.
  *
  * Parses method, path, query string, and headers from a raw HTTP request.
- * No external dependencies.
+ * All parsing is done IN-PLACE on the caller's buffer — no copies are made.
+ * The caller must keep the buffer alive for the lifetime of the request.
  */
 
 #include "cerver.h"
@@ -48,59 +49,65 @@ static void url_decode(char *str) {
 }
 
 /* ------------------------------------------------------------------ */
-/*  Parse query string: "a=1&b=2" → key-value pairs                  */
+/*  Parse query string IN-PLACE: "a=1&b=2" → key-value pairs         */
 /* ------------------------------------------------------------------ */
 
 static void parse_query_string(char *qs, cerver_request_t *req) {
     if (!qs || !*qs) return;
 
-    char *saveptr = NULL;
-    char *pair = strtok_r(qs, "&", &saveptr);
+    /* Parse directly on the buffer — no strdup needed */
+    char *p = qs;
 
-    while (pair && req->query_count < CERVER_MAX_QUERY) {
-        char *eq = strchr(pair, '=');
+    while (*p && req->query_count < CERVER_MAX_QUERY) {
+        char *pair_start = p;
+
+        /* Find end of pair (& or NUL) */
+        while (*p && *p != '&') p++;
+        if (*p == '&') *p++ = '\0';
+
+        char *eq = strchr(pair_start, '=');
         if (eq) {
             *eq = '\0';
-            req->query[req->query_count].key = pair;
+            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;
+            req->query[req->query_count].key = pair_start;
             req->query[req->query_count].value = "";
         }
         req->query_count++;
-        pair = strtok_r(NULL, "&", &saveptr);
     }
 }
 
 /* ------------------------------------------------------------------ */
-/*  Parse the HTTP request                                            */
+/*  Parse the HTTP request IN-PLACE                                   */
 /* ------------------------------------------------------------------ */
 
 int cerver_parse_request(const char *raw, size_t len, cerver_request_t *req) {
     if (!raw || len == 0) return -1;
 
-    /* We need a mutable copy because we'll be inserting NUL terminators */
-    char *buf = malloc(len + 1);
-    if (!buf) return -1;
-    memcpy(buf, raw, len);
-    buf[len] = '\0';
-
-    req->_raw_buf = buf;
+    /*
+     * We parse in-place: the caller gives us a mutable buffer (cast away
+     * const — the caller's read_full_request already owns a mutable buffer).
+     * All internal pointers (headers, query, body) reference this buffer.
+     * 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 */
+
+    /* We no longer allocate _raw_buf — the read buffer IS the raw buffer */
+    req->_raw_buf = NULL;
     req->_raw_len = len;
 
     /* ---- Request line: METHOD PATH HTTP/1.x ---- */
     char *line_end = strstr(buf, "\r\n");
-    if (!line_end) {
-        free(buf);
-        return -1;
-    }
+    if (!line_end) return -1;
     *line_end = '\0';
 
     /* Method */
     char *sp1 = strchr(buf, ' ');
-    if (!sp1) { free(buf); return -1; }
+    if (!sp1) return -1;
     *sp1 = '\0';
 
     size_t method_len = (size_t)(sp1 - buf);
@@ -117,8 +124,16 @@ int cerver_parse_request(const char *raw, size_t len, cerver_request_t *req) {
     char *qmark = strchr(path_start, '?');
     if (qmark) {
         *qmark = '\0';
-        strncpy(req->query_string, qmark + 1, sizeof(req->query_string) - 1);
-        req->query_string[sizeof(req->query_string) - 1] = '\0';
+        /* Point query_string directly into the buffer */
+        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';
+
+        /* Parse query params in-place from query_string
+         * (we copied to req->query_string so params point into req memory) */
+        parse_query_string(req->query_string, req);
     }
 
     /* Decode and store path */
@@ -132,17 +147,6 @@ int cerver_parse_request(const char *raw, size_t len, cerver_request_t *req) {
         req->path[plen - 1] = '\0';
     }
 
-    /* Parse query string */
-    if (req->query_string[0]) {
-        /* We need a mutable copy for strtok */
-        char *qs_copy = strdup(req->query_string);
-        if (qs_copy) {
-            parse_query_string(qs_copy, req);
-            /* Note: keys/values point into qs_copy which we leak intentionally
-               since the request's lifetime is short (one connection). */
-        }
-    }
-
     /* ---- Headers ---- */
     char *hdr_start = line_end + 2; /* skip \r\n */
     size_t content_length = 0;