@velox0/cerver 0.3.0 → 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/README.md

@@ -1,8 +1,12 @@
+<div align="center">
+  <img src="templates/cerver.png" alt="Cerver Logo" width="120" />
+</div>
+
 # Cerver
 
 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 (~50KB) that runs with zero Node.js dependency.
+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.
 
 ## Features
 

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/commands/new.js

@@ -53,15 +53,103 @@ function newProject(name) {
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width, initial-scale=1.0">
   <title>${name}</title>
+  <link rel="icon" href="/favicon.ico" type="image/x-icon">
+  <style>
+    :root {
+      --bg-color: #0f172a;
+      --text-color: #f8fafc;
+      --accent-color: #38bdf8;
+      --card-bg: rgba(30, 41, 59, 0.7);
+    }
+    body {
+      margin: 0;
+      padding: 0;
+      font-family: 'Inter', -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
+      background-color: var(--bg-color);
+      color: var(--text-color);
+      display: flex;
+      flex-direction: column;
+      align-items: center;
+      justify-content: center;
+      min-height: 100vh;
+      background: radial-gradient(circle at top right, #1e293b, #0f172a);
+    }
+    .container {
+      background: var(--card-bg);
+      backdrop-filter: blur(12px);
+      -webkit-backdrop-filter: blur(12px);
+      border: 1px solid rgba(255, 255, 255, 0.1);
+      padding: 3rem;
+      border-radius: 16px;
+      text-align: center;
+      box-shadow: 0 25px 50px -12px rgba(0, 0, 0, 0.5);
+      max-width: 500px;
+      width: 90%;
+      animation: fadeUp 0.8s cubic-bezier(0.16, 1, 0.3, 1) forwards;
+      opacity: 0;
+      transform: translateY(20px);
+    }
+    @keyframes fadeUp {
+      to { opacity: 1; transform: translateY(0); }
+    }
+    .logo {
+      width: 120px;
+      height: 120px;
+      margin-bottom: 1.5rem;
+      border-radius: 24%;
+      box-shadow: 0 10px 25px rgba(0, 0, 0, 0.4);
+      transition: transform 0.3s cubic-bezier(0.34, 1.56, 0.64, 1);
+    }
+    .logo:hover {
+      transform: scale(1.08) rotate(-3deg);
+    }
+    h1 {
+      margin: 0 0 1rem 0;
+      font-size: 2.5rem;
+      font-weight: 700;
+      letter-spacing: -0.025em;
+    }
+    p {
+      margin: 0;
+      color: #94a3b8;
+      font-size: 1.125rem;
+      line-height: 1.6;
+    }
+    .badge {
+      display: inline-block;
+      margin-top: 2rem;
+      padding: 0.5rem 1rem;
+      background: rgba(56, 189, 248, 0.1);
+      color: var(--accent-color);
+      border-radius: 9999px;
+      font-size: 0.875rem;
+      font-weight: 600;
+      border: 1px solid rgba(56, 189, 248, 0.2);
+    }
+  </style>
 </head>
 <body>
-  <h1>${name}</h1>
-  <p>Served by cerver.</p>
+  <div class="container">
+    <img src="/cerver.png" alt="cerver logo" class="logo">
+    <h1>${name}</h1>
+    <p>Your ultra-fast, native web application is running.</p>
+    <div class="badge">Powered by cerver</div>
+  </div>
 </body>
 </html>
 `
   );
 
+  // Copy standard static assets
+  fs.copyFileSync(
+    path.join(templatesDir, "cerver.png"),
+    path.join(projectDir, "public", "cerver.png")
+  );
+  fs.copyFileSync(
+    path.join(templatesDir, "favicon.ico"),
+    path.join(projectDir, "public", "favicon.ico")
+  );
+
   // package.json
   fs.writeFileSync(
     path.join(projectDir, "package.json"),
@@ -83,6 +171,8 @@ function newProject(name) {
   console.log("  Created:");
   console.log("    app/routes/index.js");
   console.log("    public/index.html");
+  console.log("    public/cerver.png");
+  console.log("    public/favicon.ico");
   console.log("    cerver.config.js");
   console.log("    package.json");
   console.log("");

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.0",
+  "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 */