@velox0/cerver 0.2.0 → 0.3.1

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

@@ -154,6 +154,22 @@ async function generateEmbeddedAssets(assets, shouldMinify, compression) {
       brName,
       brLen,
     });
+
+    /* Auto-alias: /any/path/index.html → /any/path */
+    if (asset.servePath.endsWith("/index.html")) {
+      const dirPath = asset.servePath === "/index.html"
+        ? "/"
+        : asset.servePath.slice(0, -"/index.html".length);
+      assetEntries.push({
+        name,
+        servePath: dirPath,
+        mime,
+        gzName,
+        gzLen,
+        brName,
+        brLen,
+      });
+    }
   }
 
   /* Generate the asset table */

package/lib/codegen/generator.js

@@ -85,7 +85,7 @@ function generateServer(routes, config, assetsCode) {
   lines.push("    if (env_port) port = atoi(env_port);");
   lines.push("");
   lines.push("    cerver_server_t srv;");
-  lines.push("    cerver_init(&srv, port);");
+  lines.push(`    cerver_init(&srv, port, ${config.threads});`);
   lines.push("");
   lines.push(
     "    cerver_add_routes(&srv, cerver_routes, cerver_route_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

@@ -57,6 +57,7 @@ function compile(distDir, runtimeDir, opts) {
     serverC,
     ...runtimeSources,
     `-I${runtimeDir}`,
+    "-lpthread",
   ];
 
   if (opts && opts.static) {

package/lib/config.js

@@ -8,6 +8,7 @@ const DEFAULTS = {
   embed: true,
   minify: true,
   compression: "none",
+  threads: 4,
 };
 
 /**
@@ -45,6 +46,9 @@ function loadConfig(projectDir) {
   if (!["none", "gzip", "brotli", "both"].includes(config.compression)) {
     throw new Error(`cerver: unsupported compression "${config.compression}"`);
   }
+  if (!Number.isInteger(config.threads) || config.threads < 1 || config.threads > 64) {
+    throw new Error(`cerver: invalid thread count ${config.threads} (must be 1-64)`);
+  }
 
   return config;
 }

package/package.json

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

package/runtime/cerver.h

@@ -11,6 +11,7 @@
 
 #include <stddef.h>
 #include <stdint.h>
+#include <pthread.h>
 
 /* ------------------------------------------------------------------ */
 /*  Limits                                                            */
@@ -22,8 +23,12 @@
 #define CERVER_MAX_PATH        2048
 #define CERVER_MAX_HEADER_VAL  4096
 #define CERVER_READ_BUF        8192
+#define CERVER_READ_BUF_MAX    (1 << 20)   /* 1 MB hard limit */
 #define CERVER_MAX_ROUTES      256
 
+#define CERVER_THREAD_POOL_DEFAULT  4
+#define CERVER_TASK_QUEUE_SIZE      256
+
 /* ------------------------------------------------------------------ */
 /*  Key-value pair (used for headers, query params, route params)     */
 /* ------------------------------------------------------------------ */
@@ -146,10 +151,20 @@ typedef struct {
     int              asset_count;
     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;
 
 /* Server lifecycle */
-int  cerver_init(cerver_server_t *srv, int port);
+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);

package/runtime/server.c

@@ -1,7 +1,9 @@
 /*
- * server.c — Socket setup and event loop for the cerver runtime.
+ * server.c — Socket setup, thread pool, and event loop for the cerver runtime.
  *
  * Uses kqueue on macOS, epoll on Linux, with a select() fallback.
+ * Requests are dispatched to a fixed-size thread pool via a ring-buffer
+ * task queue protected by a mutex + condition variable.
  */
 
 #include "cerver.h"
@@ -17,6 +19,7 @@
 #include <sys/types.h>
 #include <netinet/in.h>
 #include <arpa/inet.h>
+#include <pthread.h>
 
 /* Platform-specific event API */
 #if defined(__APPLE__) || defined(__FreeBSD__)
@@ -49,53 +52,122 @@ static int set_nonblocking(int fd) {
 }
 
 /* ------------------------------------------------------------------ */
-/*  Handle a single connection: read, parse, dispatch, respond        */
+/*  memmem fallback for systems that lack it                          */
 /* ------------------------------------------------------------------ */
 
-static int set_blocking(int fd) {
-    int flags = fcntl(fd, F_GETFL, 0);
-    if (flags < 0) return -1;
-    return fcntl(fd, F_SETFL, flags & ~O_NONBLOCK);
+#if !defined(__APPLE__) && !defined(__linux__) && !defined(_GNU_SOURCE)
+static void *cerver_memmem(const void *hay, size_t haylen,
+                           const void *needle, size_t nlen) {
+    if (nlen == 0) return (void *)hay;
+    if (nlen > haylen) return NULL;
+    const char *p = (const char *)hay;
+    const char *end = p + haylen - nlen;
+    for (; p <= end; p++) {
+        if (memcmp(p, needle, nlen) == 0) return (void *)p;
+    }
+    return NULL;
 }
+#define memmem cerver_memmem
+#endif
+
+/* ------------------------------------------------------------------ */
+/*  Buffered read — accumulates until \r\n\r\n or limit reached       */
+/* ------------------------------------------------------------------ */
+
+static char *read_full_request(int fd, size_t *out_len) {
+    size_t cap = CERVER_READ_BUF;
+    size_t len = 0;
+    char *buf = malloc(cap + 1); /* +1 for null terminator */
+    if (!buf) return NULL;
+
+    while (len < (size_t)CERVER_READ_BUF_MAX) {
+        ssize_t n = read(fd, buf + len, cap - len);
+        if (n <= 0) break;
+        len += (size_t)n;
+
+        /* Check for end of headers */
+        if (len >= 4 && memmem(buf, len, "\r\n\r\n", 4)) break;
+
+        /* Grow buffer if full */
+        if (len == cap) {
+            size_t newcap = cap * 2;
+            if (newcap > (size_t)CERVER_READ_BUF_MAX)
+                newcap = (size_t)CERVER_READ_BUF_MAX;
+            char *tmp = realloc(buf, newcap + 1);
+            if (!tmp) { free(buf); return NULL; }
+            buf = tmp;
+            cap = newcap;
+        }
+    }
+
+    if (len == 0) {
+        free(buf);
+        return NULL;
+    }
+
+    buf[len] = '\0';
+    *out_len = len;
+    return buf;
+}
+
+/* ------------------------------------------------------------------ */
+/*  Handle a single connection: read, parse, dispatch, respond        */
+/* ------------------------------------------------------------------ */
 
 static void handle_connection(cerver_server_t *srv, int client_fd) {
-    /* Client sockets may inherit non-blocking mode from listener.
-       Set to blocking so read() waits for data. */
-    set_blocking(client_fd);
+    /* Ensure the client socket is in blocking mode for reads.
+       Some platforms inherit O_NONBLOCK from the listening socket. */
+    int flags = fcntl(client_fd, F_GETFL, 0);
+    if (flags >= 0 && (flags & O_NONBLOCK)) {
+        fcntl(client_fd, F_SETFL, flags & ~O_NONBLOCK);
+    }
+
+    /* Set a read timeout so workers don't block on stale connections */
+    struct timeval tv = { 5, 0 }; /* 5 seconds */
+    setsockopt(client_fd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
 
-    char buf[CERVER_READ_BUF];
-    ssize_t n = read(client_fd, buf, sizeof(buf) - 1);
+    /* Read the full request with buffering */
+    size_t req_len = 0;
+    char *buf = read_full_request(client_fd, &req_len);
 
-    if (n <= 0) {
+    if (!buf || req_len == 0) {
+        if (buf) free(buf);
         close(client_fd);
         return;
     }
-    buf[n] = '\0';
 
     /* Parse HTTP request */
     cerver_request_t req;
     memset(&req, 0, sizeof(req));
 
-    if (cerver_parse_request(buf, (size_t)n, &req) < 0) {
+    if (cerver_parse_request(buf, req_len, &req) < 0) {
         /* Bad request — send 400 */
         const char *resp = "HTTP/1.1 400 Bad Request\r\nContent-Length: 11\r\nConnection: close\r\n\r\nBad Request";
         write(client_fd, resp, strlen(resp));
+        free(buf);
         close(client_fd);
         return;
     }
 
+    /*
+     * The parser malloc'd its own mutable copy (req._raw_buf) and all
+     * internal pointers (path, headers, etc.) reference that copy.
+     * We can now free our original read buffer.
+     */
+    free(buf);
+
     /* Prepare response */
     cerver_response_t res;
     memset(&res, 0, sizeof(res));
 
-    /* Try to dispatch to a route handler */
-    cerver_handler_fn handler = cerver_dispatch(srv, &req);
+    /* Try static assets first — files take priority over route handlers */
+    if (cerver_serve_static(srv, &req, &res) < 0) {
+        /* No static file found — try route handlers */
+        cerver_handler_fn handler = cerver_dispatch(srv, &req);
 
-    if (handler) {
-        handler(&req, &res);
-    } else {
-        /* Try static assets */
-        if (cerver_serve_static(srv, &req, &res) < 0) {
+        if (handler) {
+            handler(&req, &res);
+        } else {
             /* 404 */
             cerver_res_text(&res, 404, "Not Found");
         }
@@ -115,16 +187,91 @@ static void handle_connection(cerver_server_t *srv, int client_fd) {
     close(client_fd);
 }
 
+/* ------------------------------------------------------------------ */
+/*  Thread pool — task queue (ring buffer)                             */
+/* ------------------------------------------------------------------ */
+
+static int enqueue_task(cerver_server_t *srv, int client_fd) {
+    pthread_mutex_lock(&srv->tq_mutex);
+
+    if (srv->tq_count >= CERVER_TASK_QUEUE_SIZE) {
+        /* Queue full — drop connection */
+        pthread_mutex_unlock(&srv->tq_mutex);
+        const char *resp = "HTTP/1.1 503 Service Unavailable\r\n"
+                           "Content-Length: 19\r\nConnection: close\r\n\r\n"
+                           "Service Unavailable";
+        write(client_fd, resp, strlen(resp));
+        close(client_fd);
+        return -1;
+    }
+
+    srv->task_queue[srv->tq_tail] = client_fd;
+    srv->tq_tail = (srv->tq_tail + 1) % CERVER_TASK_QUEUE_SIZE;
+    srv->tq_count++;
+
+    pthread_cond_signal(&srv->tq_cond);
+    pthread_mutex_unlock(&srv->tq_mutex);
+    return 0;
+}
+
+static int dequeue_task(cerver_server_t *srv) {
+    pthread_mutex_lock(&srv->tq_mutex);
+
+    while (srv->tq_count == 0 && srv->running) {
+        pthread_cond_wait(&srv->tq_cond, &srv->tq_mutex);
+    }
+
+    if (!srv->running && srv->tq_count == 0) {
+        pthread_mutex_unlock(&srv->tq_mutex);
+        return -1; /* shutdown signal */
+    }
+
+    int fd = srv->task_queue[srv->tq_head];
+    srv->tq_head = (srv->tq_head + 1) % CERVER_TASK_QUEUE_SIZE;
+    srv->tq_count--;
+
+    pthread_mutex_unlock(&srv->tq_mutex);
+    return fd;
+}
+
+/* ------------------------------------------------------------------ */
+/*  Worker thread entry point                                         */
+/* ------------------------------------------------------------------ */
+
+static void *worker_thread(void *arg) {
+    cerver_server_t *srv = (cerver_server_t *)arg;
+
+    while (srv->running) {
+        int client_fd = dequeue_task(srv);
+        if (client_fd < 0) break; /* shutdown */
+
+        handle_connection(srv, client_fd);
+    }
+
+    return NULL;
+}
+
 /* ------------------------------------------------------------------ */
 /*  Server init                                                       */
 /* ------------------------------------------------------------------ */
 
-int cerver_init(cerver_server_t *srv, int port) {
+int cerver_init(cerver_server_t *srv, int port, int threads) {
     memset(srv, 0, sizeof(*srv));
     srv->port = port;
     srv->sock_fd = -1;
     srv->running = 0;
     srv->public_dir = NULL;
+
+    /* Thread pool config */
+    srv->thread_count = (threads > 0) ? threads : CERVER_THREAD_POOL_DEFAULT;
+    srv->threads = NULL;
+    srv->tq_head = 0;
+    srv->tq_tail = 0;
+    srv->tq_count = 0;
+
+    pthread_mutex_init(&srv->tq_mutex, NULL);
+    pthread_cond_init(&srv->tq_cond, NULL);
+
     return 0;
 }
 
@@ -144,6 +291,43 @@ void cerver_set_public_dir(cerver_server_t *srv, const char *dir) {
     srv->public_dir = dir;
 }
 
+/* ------------------------------------------------------------------ */
+/*  Start thread pool                                                 */
+/* ------------------------------------------------------------------ */
+
+static int start_thread_pool(cerver_server_t *srv) {
+    srv->threads = malloc(sizeof(pthread_t) * (size_t)srv->thread_count);
+    if (!srv->threads) {
+        perror("cerver: malloc threads");
+        return -1;
+    }
+
+    /* Use 2 MB stack per worker (handles deep call chains with large buffers) */
+    pthread_attr_t attr;
+    pthread_attr_init(&attr);
+    pthread_attr_setstacksize(&attr, 2 * 1024 * 1024);
+
+    for (int i = 0; i < srv->thread_count; i++) {
+        if (pthread_create(&srv->threads[i], &attr, worker_thread, srv) != 0) {
+            perror("cerver: pthread_create");
+            /* Clean up already-created threads */
+            srv->running = 0;
+            pthread_cond_broadcast(&srv->tq_cond);
+            for (int j = 0; j < i; j++) {
+                pthread_join(srv->threads[j], NULL);
+            }
+            free(srv->threads);
+            srv->threads = NULL;
+            return -1;
+        }
+    }
+
+    pthread_attr_destroy(&attr);
+
+    printf("cerver: started %d worker thread(s)\n", srv->thread_count);
+    return 0;
+}
+
 /* ------------------------------------------------------------------ */
 /*  Server listen — event loop                                        */
 /* ------------------------------------------------------------------ */
@@ -190,7 +374,13 @@ int cerver_listen(cerver_server_t *srv) {
 
     srv->running = 1;
 
-    printf("cerver: listening on http://0.0.0.0:%d\n", srv->port);
+    printf("cerver: listening on http://localhost:%d\n", srv->port);
+
+    /* Start the thread pool */
+    if (start_thread_pool(srv) < 0) {
+        close(srv->sock_fd);
+        return -1;
+    }
 
 /* ================================================================== */
 /*  kqueue event loop (macOS / FreeBSD)                               */
@@ -236,7 +426,7 @@ int cerver_listen(cerver_server_t *srv) {
                         perror("cerver: accept");
                         break;
                     }
-                    handle_connection(srv, client_fd);
+                    enqueue_task(srv, client_fd);
                 }
             }
         }
@@ -285,7 +475,7 @@ int cerver_listen(cerver_server_t *srv) {
                         perror("cerver: accept");
                         break;
                     }
-                    handle_connection(srv, client_fd);
+                    enqueue_task(srv, client_fd);
                 }
             }
         }
@@ -319,7 +509,7 @@ int cerver_listen(cerver_server_t *srv) {
                                    (struct sockaddr *)&client_addr,
                                    &client_len);
             if (client_fd >= 0) {
-                handle_connection(srv, client_fd);
+                enqueue_task(srv, client_fd);
             }
         }
     }
@@ -335,10 +525,31 @@ int cerver_listen(cerver_server_t *srv) {
 /* ------------------------------------------------------------------ */
 
 void cerver_shutdown(cerver_server_t *srv) {
+    srv->running = 0;
+
+    /* Wake all worker threads so they can exit */
+    pthread_mutex_lock(&srv->tq_mutex);
+    pthread_cond_broadcast(&srv->tq_cond);
+    pthread_mutex_unlock(&srv->tq_mutex);
+
+    /* Join all worker threads */
+    if (srv->threads) {
+        for (int i = 0; i < srv->thread_count; i++) {
+            pthread_join(srv->threads[i], NULL);
+        }
+        free(srv->threads);
+        srv->threads = NULL;
+    }
+
+    /* Close listener socket */
     if (srv->sock_fd >= 0) {
         close(srv->sock_fd);
         srv->sock_fd = -1;
     }
-    srv->running = 0;
+
+    /* Destroy synchronization primitives */
+    pthread_mutex_destroy(&srv->tq_mutex);
+    pthread_cond_destroy(&srv->tq_cond);
+
     printf("\ncerver: server stopped\n");
 }

package/test/run.js

@@ -198,6 +198,7 @@ test("loadConfig merges defaults and supports export default configs", () => {
       embed: true,
       minify: true,
       compression: "none",
+      threads: 4,
     });
 
     writeFile(
@@ -210,6 +211,7 @@ test("loadConfig merges defaults and supports export default configs", () => {
       embed: false,
       minify: false,
       compression: "gzip",
+      threads: 4,
     });
   } finally {
     cleanup(dir);