@velox0/cerver 0.1.0 → 0.2.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,64 @@ 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,
+    });
   }
 
   /* 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/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/config.js

@@ -42,7 +42,7 @@ 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}"`);
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@velox0/cerver",
-  "version": "0.1.0",
+  "version": "0.2.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

@@ -125,6 +125,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;
 
 /* ------------------------------------------------------------------ */

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

package/runtime/static.c

@@ -3,6 +3,7 @@
  *
  * In embedded mode, serves from the compiled-in asset array.
  * In external mode, serves from the filesystem (public/ directory).
+ * Supports pre-compressed gzip/brotli variants and cache headers.
  */
 
 #include "cerver.h"
@@ -29,6 +30,40 @@ static int path_is_safe(const char *path) {
     return 1;
 }
 
+/* ------------------------------------------------------------------ */
+/*  Accept-Encoding parsing                                           */
+/* ------------------------------------------------------------------ */
+
+typedef struct {
+    int accepts_gzip;
+    int accepts_br;
+} encoding_prefs_t;
+
+static encoding_prefs_t parse_accept_encoding(const cerver_request_t *req) {
+    encoding_prefs_t prefs = { 0, 0 };
+    const char *ae = cerver_req_header(req, "Accept-Encoding");
+    if (!ae) return prefs;
+
+    if (strstr(ae, "br")) prefs.accepts_br = 1;
+    if (strstr(ae, "gzip")) prefs.accepts_gzip = 1;
+
+    return prefs;
+}
+
+/* ------------------------------------------------------------------ */
+/*  Cache header helper                                               */
+/* ------------------------------------------------------------------ */
+
+static void add_cache_headers(cerver_response_t *res, const char *path) {
+    /* Hashed/versioned assets (in /static/) get long cache */
+    if (strstr(path, "/static/") || strstr(path, "/assets/")) {
+        cerver_res_header(res, "Cache-Control", "public, max-age=31536000, immutable");
+    } else {
+        /* HTML and other top-level files get short cache with revalidation */
+        cerver_res_header(res, "Cache-Control", "public, max-age=3600, must-revalidate");
+    }
+}
+
 /* ------------------------------------------------------------------ */
 /*  Serve from embedded assets                                        */
 /* ------------------------------------------------------------------ */
@@ -38,33 +73,59 @@ static int serve_embedded(cerver_server_t *srv, cerver_request_t *req,
     if (!srv->assets || srv->asset_count == 0) return -1;
 
     const char *path = req->path;
+    const cerver_asset_t *found = NULL;
 
     /* Try exact match first */
     for (int i = 0; i < srv->asset_count; i++) {
         if (strcmp(srv->assets[i].path, path) == 0) {
-            cerver_res_file(res, 200, srv->assets[i].mime_type,
-                           srv->assets[i].data, srv->assets[i].data_len);
-            return 0;
+            found = &srv->assets[i];
+            break;
         }
     }
 
     /* Try with /index.html appended (for directory-like paths) */
-    char index_path[CERVER_MAX_PATH];
-    if (path[strlen(path) - 1] == '/') {
-        snprintf(index_path, sizeof(index_path), "%sindex.html", path);
-    } else {
-        snprintf(index_path, sizeof(index_path), "%s/index.html", path);
-    }
+    if (!found) {
+        char index_path[CERVER_MAX_PATH];
+        if (path[strlen(path) - 1] == '/') {
+            snprintf(index_path, sizeof(index_path), "%sindex.html", path);
+        } else {
+            snprintf(index_path, sizeof(index_path), "%s/index.html", path);
+        }
 
-    for (int i = 0; i < srv->asset_count; i++) {
-        if (strcmp(srv->assets[i].path, index_path) == 0) {
-            cerver_res_file(res, 200, srv->assets[i].mime_type,
-                           srv->assets[i].data, srv->assets[i].data_len);
-            return 0;
+        for (int i = 0; i < srv->asset_count; i++) {
+            if (strcmp(srv->assets[i].path, index_path) == 0) {
+                found = &srv->assets[i];
+                break;
+            }
         }
     }
 
-    return -1;
+    if (!found) return -1;
+
+    /* Check for pre-compressed variants */
+    encoding_prefs_t enc = parse_accept_encoding(req);
+
+    if (enc.accepts_br && found->data_br && found->data_br_len > 0) {
+        /* Serve brotli */
+        cerver_res_file(res, 200, found->mime_type,
+                       found->data_br, found->data_br_len);
+        cerver_res_header(res, "Content-Encoding", "br");
+        cerver_res_header(res, "Vary", "Accept-Encoding");
+    } else if (enc.accepts_gzip && found->data_gz && found->data_gz_len > 0) {
+        /* Serve gzip */
+        cerver_res_file(res, 200, found->mime_type,
+                       found->data_gz, found->data_gz_len);
+        cerver_res_header(res, "Content-Encoding", "gzip");
+        cerver_res_header(res, "Vary", "Accept-Encoding");
+    } else {
+        /* Serve uncompressed */
+        cerver_res_file(res, 200, found->mime_type,
+                       found->data, found->data_len);
+    }
+
+    add_cache_headers(res, found->path);
+
+    return 0;
 }
 
 /* ------------------------------------------------------------------ */
@@ -123,6 +184,8 @@ static int serve_filesystem(cerver_server_t *srv, cerver_request_t *req,
     res->body_len = file_size;
     res->_body_owned = 1; /* We malloc'd this */
 
+    add_cache_headers(res, path);
+
     return 0;
 }
 

package/test/run.js

@@ -0,0 +1,353 @@
+"use strict";
+
+const assert = require("assert/strict");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const zlib = require("zlib");
+
+const { discoverAssets } = require("../lib/assets/discover");
+const { compressContent, isCompressible } = require("../lib/assets/compress");
+const { generateEmbeddedAssets, mimeFromExt, varName } = require("../lib/assets/embed");
+const { minifyContent } = require("../lib/assets/minify");
+const {
+  cString,
+  emitExpression,
+  emitStatement,
+  handlerName,
+} = require("../lib/codegen/emit");
+const { generateRouteTable } = require("../lib/codegen/route_table");
+const { loadConfig } = require("../lib/config");
+const IR = require("../lib/ir/types");
+const { transformFile } = require("../lib/ir/transform");
+const { discoverRoutes } = require("../lib/parser/discover");
+const { parseSource } = require("../lib/parser/parse");
+const { validate } = require("../lib/validator/validate");
+
+const tests = [];
+
+function test(name, fn) {
+  tests.push({ name, fn });
+}
+
+function tempDir() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), "cerver-test-"));
+}
+
+function writeFile(filePath, content) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, content);
+}
+
+function cleanup(dir) {
+  fs.rmSync(dir, { recursive: true, force: true });
+}
+
+function parseAndValidate(source, filename = "route.js") {
+  const { ast } = parseSource(source, filename);
+  validate(ast, filename, source);
+  return ast;
+}
+
+test("discoverRoutes maps file routes and sorts dynamic routes last", () => {
+  const dir = tempDir();
+  try {
+    const routesDir = path.join(dir, "app", "routes");
+    writeFile(path.join(routesDir, "index.js"), "export function GET(req, res) {}");
+    writeFile(path.join(routesDir, "about.js"), "export function GET(req, res) {}");
+    writeFile(path.join(routesDir, "blog", "index.js"), "export function GET(req, res) {}");
+    writeFile(path.join(routesDir, "blog", "[slug].js"), "export function GET(req, res) {}");
+    writeFile(path.join(routesDir, "blog", "draft.txt"), "ignored");
+
+    const routes = discoverRoutes(routesDir).map((route) => ({
+      filePath: path.relative(routesDir, route.filePath),
+      urlPath: route.urlPath,
+    }));
+
+    assert.deepEqual(routes, [
+      { filePath: "index.js", urlPath: "/" },
+      { filePath: "about.js", urlPath: "/about" },
+      { filePath: path.join("blog", "index.js"), urlPath: "/blog" },
+      { filePath: path.join("blog", "[slug].js"), urlPath: "/blog/:slug" },
+    ]);
+  } finally {
+    cleanup(dir);
+  }
+});
+
+test("discoverRoutes returns an empty list when the routes directory is missing", () => {
+  const dir = tempDir();
+  try {
+    assert.deepEqual(discoverRoutes(path.join(dir, "missing")), []);
+  } finally {
+    cleanup(dir);
+  }
+});
+
+test("validate accepts supported handler syntax", () => {
+  const source = `
+export function GET(req, res) {
+  const id = req.params.id;
+  if (id === "42") {
+    return res.json(200, '{"ok":true}');
+  }
+  return res.text(404, "missing");
+}
+`;
+
+  assert.doesNotThrow(() => parseAndValidate(source));
+});
+
+test("validate rejects unsupported HTTP methods and async handlers", () => {
+  const badMethod = parseSource(
+    "export function PUT(req, res) { return res.text(200, 'no'); }",
+    "bad-method.js"
+  );
+  assert.throws(
+    () => validate(badMethod.ast, "bad-method.js", badMethod.source),
+    /exported function "PUT" is not a valid HTTP method/
+  );
+
+  const asyncHandler = parseSource(
+    "export async function GET(req, res) { await work(); return res.text(200, 'ok'); }",
+    "async-route.js"
+  );
+  assert.throws(
+    () => validate(asyncHandler.ast, "async-route.js", asyncHandler.source),
+    /async functions are not supported[\s\S]*async\/await is not supported/
+  );
+});
+
+test("transformFile produces route IR for params, query, headers, and template returns", () => {
+  const source = `
+export function GET(req, res) {
+  const userId = req.params.id;
+  if (req.query.preview === "true" && req.headers["x-mode"] !== "off") {
+    return res.html(200, \`<h1>\${userId}</h1>\`);
+  }
+  return res.text(404, "missing");
+}
+`;
+  const ast = parseAndValidate(source, "users.js");
+  const routes = transformFile(ast, "/users/:id");
+
+  assert.equal(routes.length, 1);
+  assert.equal(routes[0].method, "GET");
+  assert.equal(routes[0].urlPath, "/users/:id");
+  assert.deepEqual(routes[0].params, ["id"]);
+
+  const variable = routes[0].handler.variables[0];
+  assert.equal(variable.name, "userId");
+  assert.equal(variable.initExpr.type, "ParamAccess");
+  assert.equal(variable.initExpr.paramName, "id");
+
+  const [ifStmt, fallback] = routes[0].handler.body;
+  assert.equal(ifStmt.type, "If");
+  assert.equal(ifStmt.condition.type, "Logical");
+  assert.equal(ifStmt.condition.left.left.type, "QueryAccess");
+  assert.equal(ifStmt.condition.right.left.type, "HeaderAccess");
+  assert.equal(ifStmt.thenBody[0].responseType, "html");
+  assert.equal(ifStmt.thenBody[0].value.type, "Concat");
+  assert.equal(fallback.status, 404);
+});
+
+test("emit helpers escape C strings and map IR expressions", () => {
+  assert.equal(cString('a"b\\c\n'), '"a\\"b\\\\c\\n"');
+  assert.equal(handlerName("GET", "/"), "handle_GET_index");
+  assert.equal(handlerName("POST", "/users/:id"), "handle_POST_users_id");
+
+  const comparison = IR.IRComparison(
+    "===",
+    IR.IRParamAccess("id"),
+    IR.IRStringLiteral("42")
+  );
+  assert.equal(
+    emitExpression(comparison),
+    '(strcmp(cerver_req_param(req, "id"), "42") == 0)'
+  );
+
+  assert.deepEqual(
+    emitStatement(IR.IRReturn("text", 201, IR.IRStringLiteral("created")), 1),
+    [
+      '    cerver_res_text(res, 201, "created");',
+      "    return;",
+    ]
+  );
+});
+
+test("generateRouteTable emits forward declarations, entries, and count", () => {
+  const routes = [
+    IR.IRRoute("GET", "/", [], IR.IRHandler([], [])),
+    IR.IRRoute("POST", "/users/:id", ["id"], IR.IRHandler([], [])),
+  ];
+
+  const code = generateRouteTable(routes);
+
+  assert.match(code, /static void handle_GET_index\(cerver_request_t \*req, cerver_response_t \*res\);/);
+  assert.match(code, /static cerver_route_t cerver_routes\[\] = \{/);
+  assert.match(code, /\{ "GET", "\/", handle_GET_index \},/);
+  assert.match(code, /\{ "POST", "\/users\/:id", handle_POST_users_id \},/);
+  assert.match(code, /static const int cerver_route_count = 2;/);
+});
+
+test("loadConfig merges defaults and supports export default configs", () => {
+  const dir = tempDir();
+  try {
+    assert.deepEqual(loadConfig(dir), {
+      port: 8080,
+      embed: true,
+      minify: true,
+      compression: "none",
+    });
+
+    writeFile(
+      path.join(dir, "cerver.config.js"),
+      'export default { port: 3001, embed: false, minify: false, compression: "gzip" };\n'
+    );
+
+    assert.deepEqual(loadConfig(dir), {
+      port: 3001,
+      embed: false,
+      minify: false,
+      compression: "gzip",
+    });
+  } finally {
+    cleanup(dir);
+  }
+});
+
+test("loadConfig rejects invalid ports and compression values", () => {
+  const dir = tempDir();
+  try {
+    writeFile(path.join(dir, "cerver.config.js"), "module.exports = { port: 70000 };\n");
+    assert.throws(() => loadConfig(dir), /invalid port 70000/);
+
+    writeFile(path.join(dir, "cerver.config.js"), 'module.exports = { compression: "zip" };\n');
+    assert.throws(() => loadConfig(dir), /unsupported compression "zip"/);
+  } finally {
+    cleanup(dir);
+  }
+});
+
+test("discoverAssets maps public files and skips dotfiles", () => {
+  const dir = tempDir();
+  try {
+    const publicDir = path.join(dir, "public");
+    writeFile(path.join(publicDir, "index.html"), "<h1>Hello</h1>");
+    writeFile(path.join(publicDir, ".secret"), "ignore me");
+    writeFile(path.join(publicDir, "css", "app.css"), "body { color: red; }");
+
+    const assets = discoverAssets(publicDir)
+      .map((asset) => ({
+        servePath: asset.servePath,
+        ext: asset.ext,
+        size: asset.size,
+      }))
+      .sort((a, b) => a.servePath.localeCompare(b.servePath));
+
+    assert.deepEqual(assets, [
+      { servePath: "/css/app.css", ext: ".css", size: Buffer.byteLength("body { color: red; }") },
+      { servePath: "/index.html", ext: ".html", size: Buffer.byteLength("<h1>Hello</h1>") },
+    ]);
+  } finally {
+    cleanup(dir);
+  }
+});
+
+test("asset helpers generate stable names and MIME types", () => {
+  assert.equal(varName("/static/app.min.css"), "asset_static_app_min_css");
+  assert.equal(mimeFromExt(".json"), "application/json; charset=utf-8");
+  assert.equal(mimeFromExt(".unknown"), "application/octet-stream");
+});
+
+test("minifyContent minifies CSS content", async () => {
+  const source = Buffer.from("/* comment */\nbody { color: red; margin: 0; }\n", "utf8");
+  const minified = await minifyContent(source, ".css");
+  const text = minified.toString("utf8");
+
+  assert.ok(text.length < source.length);
+  assert.doesNotMatch(text, /comment/);
+  assert.match(text, /color:red/);
+});
+
+test("compression helpers identify compressible MIME types and round-trip gzip", async () => {
+  const source = Buffer.from("hello cerver ".repeat(80), "utf8");
+
+  assert.equal(isCompressible("text/css; charset=utf-8"), true);
+  assert.equal(isCompressible("application/json; charset=utf-8"), true);
+  assert.equal(isCompressible("image/png"), false);
+
+  const compressed = await compressContent(source, "gzip");
+  assert.ok(compressed.length < source.length);
+  assert.equal(zlib.gunzipSync(compressed).toString("utf8"), source.toString("utf8"));
+});
+
+test("generateEmbeddedAssets emits C arrays and asset table entries", async () => {
+  const dir = tempDir();
+  try {
+    const filePath = path.join(dir, "public", "css", "app.css");
+    const content = "body { color: red; }";
+    writeFile(filePath, content);
+
+    const code = await generateEmbeddedAssets(
+      [{ filePath, servePath: "/css/app.css", ext: ".css" }],
+      false
+    );
+
+    assert.match(code, /static const unsigned char asset_css_app_css\[\] = \{/);
+    assert.match(
+      code,
+      new RegExp(`static const unsigned int asset_css_app_css_len = ${Buffer.byteLength(content)};`)
+    );
+    assert.match(
+      code,
+      /\{ "\/css\/app\.css", "text\/css; charset=utf-8", asset_css_app_css, asset_css_app_css_len, .* \},/
+    );
+    assert.match(code, /static const int cerver_embedded_asset_count = 1;/);
+  } finally {
+    cleanup(dir);
+  }
+});
+
+test("generateEmbeddedAssets can emit gzip variants for compressible assets", async () => {
+  const dir = tempDir();
+  try {
+    const filePath = path.join(dir, "public", "css", "app.css");
+    const content = "body { color: red; }\n".repeat(80);
+    writeFile(filePath, content);
+
+    const code = await generateEmbeddedAssets(
+      [{ filePath, servePath: "/css/app.css", ext: ".css" }],
+      false,
+      "gzip"
+    );
+
+    assert.match(code, /static const unsigned char asset_css_app_css_gz\[\] = \{/);
+    assert.match(code, /static const unsigned int asset_css_app_css_gz_len = \d+;/);
+    assert.match(
+      code,
+      /\{ "\/css\/app\.css", "text\/css; charset=utf-8", asset_css_app_css, asset_css_app_css_len, asset_css_app_css_gz, asset_css_app_css_gz_len, NULL, 0 \},/
+    );
+  } finally {
+    cleanup(dir);
+  }
+});
+
+(async () => {
+  let passed = 0;
+
+  for (const { name, fn } of tests) {
+    try {
+      await fn();
+      passed += 1;
+      console.log(`ok ${passed} - ${name}`);
+    } catch (err) {
+      console.error(`not ok ${passed + 1} - ${name}`);
+      console.error(err && err.stack ? err.stack : err);
+      process.exitCode = 1;
+      return;
+    }
+  }
+
+  console.log(`\n${passed} test(s) passed`);
+})();