@velox0/cerver 0.1.0 → 0.3.0

package/.github/workflows/publish.yml

@@ -0,0 +1,48 @@
+name: Publish package
+
+on:
+  push:
+    branches: [main]
+  release:
+    types: [published]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  id-token: write
+
+jobs:
+  publish:
+    name: Publish to npm
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup pnpm
+        uses: pnpm/action-setup@v4
+        with:
+          version: 10
+          run_install: false
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          registry-url: https://registry.npmjs.org
+          cache: pnpm
+
+      - name: Install dependencies
+        run: pnpm install --frozen-lockfile
+
+      - name: Run tests
+        run: pnpm test
+
+      - name: Verify package contents
+        run: npm pack --dry-run
+
+      - name: Publish to npm
+        run: npm publish --access public --provenance
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/README.md

@@ -10,32 +10,36 @@ Cerver takes a Next.js-style file-based routing structure (written in a strict s
 - **Microscopic Footprint**: Generated executables are typically ~50KB 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., `/art/[key].js`).
+- **File-Based Routing**: Intuitive `app/routes/` directory structure, supporting dynamic segments (e.g., `/item/[id].js`).
 
 ## Getting Started
 
 1. Install globally (requires `gcc` or `clang` on your system):
-   ```bash
-   npm install -g cerver
-   ```
+
+```bash
+npm i @velox0/cerver@latest
+```
 
 2. Create a new project:
-   ```bash
-   cerver new my-fast-api
-   cd my-fast-api
-   ```
+
+```bash
+cerver new my-fast-api
+cd my-fast-api
+```
 
 3. Build and Run:
-   ```bash
-   cerver build
-   cerver run
-   ```
+
+```bash
+cerver build
+cerver run
+```
 
 ## Routing
 
 Routes are defined in the `app/routes/` directory.
 
 `app/routes/index.js` (maps to `/`)
+
 ```javascript
 export function GET(req, res) {
   return res.html(200, "<h1>Hello World!</h1>");
@@ -43,6 +47,7 @@ export function GET(req, res) {
 ```
 
 `app/routes/api/status.js` (maps to `/api/status`)
+
 ```javascript
 export function GET(req, res) {
   return res.json(200, '{"status": "online"}');
@@ -50,6 +55,7 @@ export function GET(req, res) {
 ```
 
 `app/routes/users/[id].js` (maps to `/users/:id`)
+
 ```javascript
 export function GET(req, res) {
   const userId = req.params.id;
@@ -62,6 +68,7 @@ export function GET(req, res) {
 Because Cerver compiles to C, the API surface is restricted.
 
 **Request (`req`)**
+
 - `req.path` — The request URL path
 - `req.method` — The HTTP method
 - `req.headers["user-agent"]` — Access request headers
@@ -69,6 +76,7 @@ Because Cerver compiles to C, the API surface is restricted.
 - `req.params.id` — Access dynamic path segments
 
 **Response (`res`)**
+
 - `res.text(status, string)` — Send plain text
 - `res.json(status, string)` — Send JSON
 - `res.html(status, string)` — Send HTML
@@ -76,6 +84,7 @@ Because Cerver compiles to C, the API surface is restricted.
 ## Supported JavaScript
 
 Cerver supports a strict, synchronous subset of JavaScript suitable for C code generation:
+
 - `if`/`else` statements
 - `const` / `let` variable declarations
 - String and Number literals
@@ -83,6 +92,7 @@ Cerver supports a strict, synchronous subset of JavaScript suitable for C code g
 - Basic comparisons (`===`, `!==`, `<`, `>`)
 
 **Not Supported (Compile-Time Errors):**
+
 - `async`/`await` and Promises
 - Loops (`for`, `while`)
 - Classes and the `new` keyword
@@ -92,13 +102,14 @@ Cerver supports a strict, synchronous subset of JavaScript suitable for C code g
 ## Configuration
 
 `cerver.config.js`:
+
 ```javascript
 export default {
-  port: 8080,        // Default port
-  embed: true,       // Embed assets from public/ into the binary
-  minify: true,      // Minify HTML/CSS/JS before embedding
-  compression: "none" // Future: pre-compress assets
-}
+  port: 8080, // Default port
+  embed: true, // Embed assets from public/ into the binary
+  minify: true, // Minify HTML/CSS/JS before embedding
+  compression: "none", // Future: pre-compress assets
+};
 ```
 
 ## How It Works

package/bin/cerver.js

@@ -32,6 +32,16 @@ program
     build(opts);
   });
 
+program
+  .command("dev")
+  .description("Watch for changes, auto-rebuild, and restart the server")
+  .option("-p, --port <port>", "Override the port")
+  .option("--no-embed", "Serve static assets from the filesystem")
+  .action((opts) => {
+    const { dev } = require("../lib/commands/dev");
+    dev(opts);
+  });
+
 program
   .command("run")
   .description("Run the compiled binary")

package/lib/assets/compress.js

@@ -0,0 +1,55 @@
+"use strict";
+
+const zlib = require("zlib");
+
+/**
+ * Compress content using gzip or brotli.
+ *
+ * Uses Node.js built-in zlib — no external dependencies needed.
+ *
+ * @param {Buffer} content - Raw content to compress
+ * @param {"gzip"|"brotli"} algorithm - Compression algorithm
+ * @returns {Promise<Buffer>} - Compressed content
+ */
+function compressContent(content, algorithm) {
+  return new Promise((resolve, reject) => {
+    if (algorithm === "gzip") {
+      zlib.gzip(content, { level: 9 }, (err, result) => {
+        if (err) reject(err);
+        else resolve(result);
+      });
+    } else if (algorithm === "brotli") {
+      zlib.brotliCompress(
+        content,
+        {
+          params: {
+            [zlib.constants.BROTLI_PARAM_QUALITY]:
+              zlib.constants.BROTLI_MAX_QUALITY,
+          },
+        },
+        (err, result) => {
+          if (err) reject(err);
+          else resolve(result);
+        }
+      );
+    } else {
+      resolve(content);
+    }
+  });
+}
+
+/**
+ * Check if a MIME type is worth compressing.
+ * Binary formats like PNG, JPEG, WOFF2 are already compressed.
+ */
+function isCompressible(mime) {
+  return (
+    mime.startsWith("text/") ||
+    mime.includes("javascript") ||
+    mime.includes("json") ||
+    mime.includes("xml") ||
+    mime.includes("svg")
+  );
+}
+
+module.exports = { compressContent, isCompressible };

package/lib/assets/embed.js

@@ -3,6 +3,7 @@
 const fs = require("fs");
 const path = require("path");
 const { minifyContent } = require("./minify");
+const { compressContent, isCompressible } = require("./compress");
 
 /**
  * MIME type lookup for embedding.
@@ -73,10 +74,12 @@ function bufferToHexArray(buf) {
  *
  * @param {Array<{ filePath: string, servePath: string, ext: string }>} assets
  * @param {boolean} shouldMinify - Whether to minify text assets
+ * @param {string} compression - "none" | "gzip" | "brotli" | "both"
  * @returns {Promise<string>} - C source code
  */
-async function generateEmbeddedAssets(assets, shouldMinify) {
+async function generateEmbeddedAssets(assets, shouldMinify, compression) {
   const lines = [];
+  const algo = compression || "none";
 
   lines.push("/* Auto-generated embedded assets — do not edit */");
   lines.push("");
@@ -94,7 +97,7 @@ async function generateEmbeddedAssets(assets, shouldMinify) {
     const name = varName(asset.servePath);
     const mime = mimeFromExt(asset.ext);
 
-    /* Generate the byte array */
+    /* Generate the raw byte array */
     lines.push(`static const unsigned char ${name}[] = {`);
     lines.push(bufferToHexArray(content));
     lines.push("};");
@@ -103,14 +106,80 @@ async function generateEmbeddedAssets(assets, shouldMinify) {
     );
     lines.push("");
 
-    assetEntries.push({ name, servePath: asset.servePath, mime });
+    /* Generate compressed variants if the content is compressible */
+    let gzName = "NULL";
+    let gzLen = "0";
+    let brName = "NULL";
+    let brLen = "0";
+
+    if (isCompressible(mime) && algo !== "none" && content.length > 256) {
+      if (algo === "gzip" || algo === "both") {
+        const gzData = await compressContent(content, "gzip");
+        /* Only embed if compression actually saves space */
+        if (gzData.length < content.length * 0.9) {
+          gzName = `${name}_gz`;
+          gzLen = `${name}_gz_len`;
+          lines.push(`static const unsigned char ${gzName}[] = {`);
+          lines.push(bufferToHexArray(gzData));
+          lines.push("};");
+          lines.push(
+            `static const unsigned int ${gzLen} = ${gzData.length};`
+          );
+          lines.push("");
+        }
+      }
+
+      if (algo === "brotli" || algo === "both") {
+        const brData = await compressContent(content, "brotli");
+        if (brData.length < content.length * 0.9) {
+          brName = `${name}_br`;
+          brLen = `${name}_br_len`;
+          lines.push(`static const unsigned char ${brName}[] = {`);
+          lines.push(bufferToHexArray(brData));
+          lines.push("};");
+          lines.push(
+            `static const unsigned int ${brLen} = ${brData.length};`
+          );
+          lines.push("");
+        }
+      }
+    }
+
+    assetEntries.push({
+      name,
+      servePath: asset.servePath,
+      mime,
+      gzName,
+      gzLen,
+      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 */
   lines.push("static cerver_asset_t cerver_embedded_assets[] = {");
   for (const entry of assetEntries) {
     lines.push(
-      `    { "${entry.servePath}", "${entry.mime}", ${entry.name}, ${entry.name}_len },`
+      `    { "${entry.servePath}", "${entry.mime}", ` +
+        `${entry.name}, ${entry.name}_len, ` +
+        `${entry.gzName}, ${entry.gzLen}, ` +
+        `${entry.brName}, ${entry.brLen} },`
     );
   }
   lines.push("};");

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/build.js

@@ -78,9 +78,10 @@ async function build(opts) {
         );
       }
 
-      assetsCode = await generateEmbeddedAssets(assets, config.minify);
+      assetsCode = await generateEmbeddedAssets(assets, config.minify, config.compression);
       console.log(
-        `    ${assets.length} asset(s), ${(totalSize / 1024).toFixed(1)} KB total`
+        `    ${assets.length} asset(s), ${(totalSize / 1024).toFixed(1)} KB total` +
+          (config.compression !== "none" ? ` (${config.compression} compressed)` : "")
       );
     } else {
       console.log("    no assets found in public/");

package/lib/commands/dev.js

@@ -0,0 +1,146 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { spawn } = require("child_process");
+const chokidar = require("chokidar");
+const { build } = require("./build");
+
+/**
+ * Dev mode: watch for changes, auto-rebuild, auto-restart.
+ */
+async function dev(opts) {
+  const projectDir = process.cwd();
+  const binaryPath = path.join(projectDir, "dist", "server");
+
+  let serverProcess = null;
+  let building = false;
+  let pendingRebuild = false;
+
+  const port = opts.port || null;
+
+  /* ---- Initial build ---- */
+  async function rebuild() {
+    if (building) {
+      pendingRebuild = true;
+      return;
+    }
+
+    building = true;
+
+    /* Kill existing server */
+    if (serverProcess) {
+      console.log("\n  ↻ restarting...\n");
+      serverProcess.kill("SIGTERM");
+      serverProcess = null;
+      /* Small delay for port release */
+      await new Promise((r) => setTimeout(r, 200));
+    }
+
+    try {
+      await build({
+        embed: opts.embed !== undefined ? opts.embed : true,
+        minify: false, /* Skip minification in dev for speed */
+        static: false,
+      });
+
+      /* Start the server */
+      startServer();
+    } catch (err) {
+      console.error(`\n  ✗ build failed: ${err.message}\n`);
+    }
+
+    building = false;
+
+    /* If changes came in during build, rebuild again */
+    if (pendingRebuild) {
+      pendingRebuild = false;
+      await rebuild();
+    }
+  }
+
+  function startServer() {
+    if (!fs.existsSync(binaryPath)) return;
+
+    const env = { ...process.env };
+    if (port) env.CERVER_PORT = port;
+
+    serverProcess = spawn(binaryPath, [], {
+      stdio: "inherit",
+      env,
+      cwd: projectDir,
+    });
+
+    serverProcess.on("error", (err) => {
+      console.error(`  ✗ server error: ${err.message}`);
+      serverProcess = null;
+    });
+
+    serverProcess.on("exit", (code, signal) => {
+      if (signal !== "SIGTERM" && signal !== "SIGINT") {
+        console.error(`  ✗ server exited (code: ${code}, signal: ${signal})`);
+      }
+      serverProcess = null;
+    });
+  }
+
+  /* ---- Watch for changes ---- */
+  const watchPaths = [
+    path.join(projectDir, "app"),
+    path.join(projectDir, "public"),
+    path.join(projectDir, "cerver.config.js"),
+  ].filter((p) => fs.existsSync(p));
+
+  const watcher = chokidar.watch(watchPaths, {
+    ignored: [
+      /(^|[\/\\])\./,     /* dotfiles */
+      /node_modules/,
+      /dist/,
+    ],
+    persistent: true,
+    ignoreInitial: true,
+    awaitWriteFinish: {
+      stabilityThreshold: 100,
+      pollInterval: 50,
+    },
+  });
+
+  /* Debounce: collect changes for 300ms before rebuilding */
+  let debounceTimer = null;
+
+  function scheduleRebuild(changedPath) {
+    const rel = path.relative(projectDir, changedPath);
+    console.log(`  ⟐ changed: ${rel}`);
+
+    if (debounceTimer) clearTimeout(debounceTimer);
+    debounceTimer = setTimeout(() => {
+      debounceTimer = null;
+      rebuild();
+    }, 300);
+  }
+
+  watcher
+    .on("change", scheduleRebuild)
+    .on("add", scheduleRebuild)
+    .on("unlink", scheduleRebuild);
+
+  /* ---- Graceful shutdown ---- */
+  function shutdown() {
+    console.log("\n  cerver dev: shutting down...");
+    watcher.close();
+    if (debounceTimer) clearTimeout(debounceTimer);
+    if (serverProcess) {
+      serverProcess.kill("SIGTERM");
+    }
+    process.exit(0);
+  }
+
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+
+  /* ---- Start ---- */
+  console.log("\n  cerver dev — watching for changes\n");
+  await rebuild();
+}
+
+module.exports = { dev };

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,
 };
 
 /**
@@ -42,9 +43,12 @@ function loadConfig(projectDir) {
   if (typeof config.port !== "number" || config.port < 1 || config.port > 65535) {
     throw new Error(`cerver: invalid port ${config.port}`);
   }
-  if (!["none", "gzip", "brotli"].includes(config.compression)) {
+  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.1.0",
+  "version": "0.3.0",
   "description": "Compile restricted JavaScript server logic into optimized native C binaries",
   "main": "lib/index.js",
   "bin": {
@@ -18,11 +18,16 @@
     "binary",
     "framework"
   ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/velox0/cerver.git"
+  },
   "author": "Velox0",
   "license": "MIT",
   "dependencies": {
     "acorn": "^8.14.0",
     "acorn-walk": "^8.3.4",
+    "chokidar": "^3.6.0",
     "commander": "^13.1.0"
   }
 }

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)     */
 /* ------------------------------------------------------------------ */
@@ -125,6 +130,12 @@ typedef struct {
     const char          *mime_type; /* e.g. "text/html" */
     const unsigned char *data;
     size_t               data_len;
+
+    /* Pre-compressed variants (NULL if not available) */
+    const unsigned char *data_gz;
+    size_t               data_gz_len;
+    const unsigned char *data_br;
+    size_t               data_br_len;
 } cerver_asset_t;
 
 /* ------------------------------------------------------------------ */
@@ -140,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/router.c

@@ -51,7 +51,7 @@ const char *cerver_req_header(const cerver_request_t *req, const char *key) {
  * Pattern segments starting with ':' are dynamic and extract values.
  *
  * Examples:
- *   pattern="/art/:key"  path="/art/sunset"  → match, key="sunset"
+ *   pattern="/items/:id"  path="/items/123"  → match, id="123"
  *   pattern="/"          path="/"             → match
  *   pattern="/api/data"  path="/api/data"     → match
  *   pattern="/api/data"  path="/api/other"    → no match