@velox0/cerver 0.3.1 → 0.4.1

package/.github/workflows/publish.yml

@@ -2,13 +2,12 @@ name: Publish package
 
 on:
   push:
-    branches: [main]
-  release:
-    types: [published]
+    tags:
+      - "v*"
   workflow_dispatch:
 
 permissions:
-  contents: read
+  contents: write
   id-token: write
 
 jobs:
@@ -18,18 +17,18 @@ jobs:
 
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
 
       - name: Setup pnpm
-        uses: pnpm/action-setup@v4
+        uses: pnpm/action-setup@v6
         with:
           version: 10
           run_install: false
 
       - name: Setup Node.js
-        uses: actions/setup-node@v4
+        uses: actions/setup-node@v6
         with:
-          node-version: 20
+          node-version: 24
           registry-url: https://registry.npmjs.org
           cache: pnpm
 

package/lib/assets/embed.js

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

package/lib/codegen/dispatch_gen.js

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

package/lib/codegen/generator.js

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

package/lib/compiler/compile.js

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

package/package.json

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