vibe-gx 3.1.0 → 4.0.0

package/README.md

@@ -1,13 +1,13 @@
 <div align="center">
-  <img src="./assets/vlogo.png" alt="Vibe Logo" width="180" />
+  <img src="https://github.com/thesixers/vibe/blob/808b45722a0b3ca0d266215bbe4cc074f62283e5/assets/vlogo.png?raw=true" alt="Vibe Logo" width="180" />
   <h1>Vibe</h1>
   <p>
     <b>The fastest Node.js web framework with the simplest syntax.</b>
   </p>
   <p>
-    <img src="https://img.shields.io/badge/performance-14,687_RPS-brightgreen" alt="Performance" />
-    <img src="https://img.shields.io/badge/vs_Express-2.2x_faster-blue" alt="vs Express" />
-    <img src="https://img.shields.io/badge/vs_Fastify-30%25_faster-orange" alt="vs Fastify" />
+    <img src="https://img.shields.io/badge/performance-11,472_RPS-brightgreen" alt="Performance" />
+    <img src="https://img.shields.io/badge/vs_Express-4.7x_faster-blue" alt="vs Express" />
+    <img src="https://img.shields.io/badge/vs_Fastify-faster-orange" alt="vs Fastify" />
     <img src="https://img.shields.io/badge/license-MIT-green" alt="License" />
   </p>
 </div>
@@ -20,29 +20,21 @@
 npm install vibe-gx
 ```
 
-### Optional: Build C++ Native Module
-
-For maximum performance, build the optional C++ native module:
-
-```bash
-npm run build:native
-```
-
-> If the build fails, Vibe automatically falls back to pure JavaScript with zero configuration.
+> Pure JavaScript — no native dependencies, no build steps, just install and go.
 
 ---
 
 ## 🏆 Why Vibe?
 
-| Metric                    |      Vibe      |  Express  |  Fastify   |
-| :------------------------ | :------------: | :-------: | :--------: |
-| **JSON Performance**      | **14,687 RPS** | 6,629 RPS | 11,289 RPS |
-| **Install Size**          |  **~280 KB**   |   ~5 MB   |   ~4 MB    |
-| **Lines for Hello World** |       3        |     5     |     6      |
-| **Dependencies**          |       2        |    30+    |    15+     |
-| **Built-in Clustering**   |       ✅       |    ❌     |     ❌     |
-| **Built-in Caching**      |       ✅       |    ❌     |     ❌     |
-| **C++ Optimizations**     |       ✅       |    ❌     |     ❌     |
+| Metric                     |      Vibe      |  Express  |  Fastify   |
+| :------------------------- | :------------: | :-------: | :--------: |
+| **JSON Performance**       | **11,472 RPS** | 2,421 RPS | 11,334 RPS |
+| **Install Size**           |  **~280 KB**   |   ~5 MB   |   ~4 MB    |
+| **Lines for Hello World**  |       3        |     5     |     6      |
+| **Dependencies**           |       1        |    30+    |    15+     |
+| **Built-in Clustering**    |       ✅       |    ❌     |     ❌     |
+| **Built-in Caching**       |       ✅       |    ❌     |     ❌     |
+| **Code-Gen Serialization** |       ✅       |    ❌     |     ✅     |
 
 > **Vibe is faster than Fastify, simpler than Express, and 14-18x smaller than both.**
 
@@ -50,19 +42,19 @@ npm run build:native
 
 ## ⚡ Features
 
-| Feature                  | Description                                                |
-| :----------------------- | :--------------------------------------------------------- |
-| 🚀 **C++ Native Module** | JSON stringify & URL parsing in C++                        |
-| 🎯 **Hybrid Router**     | O(1) static + O(log n) Trie routing                        |
-| 🔌 **Plugin System**     | Fastify-style `register()` with encapsulation              |
-| 🎨 **Decorators**        | Extend app, request, and response                          |
-| ⚡ **Cluster Mode**      | Built-in multi-process scaling                             |
-| 💾 **LRU Cache**         | Built-in response caching with ETag                        |
-| 🔗 **Connection Pool**   | Generic pool for databases                                 |
-| 📂 **File Uploads**      | Multipart uploads with size/type validation                |
-| 🌊 **Streaming**         | Large file uploads without buffering                       |
-| 🔒 **Security**          | Path traversal protection, body limits, error sanitization |
-| 🔄 **Express Adapter**   | Use any Express middleware with `adapt()`                  |
+| Feature                       | Description                                                |
+| :---------------------------- | :--------------------------------------------------------- |
+| 🚀 **Code-Gen Serialization** | Schema-compiled JSON serializers via `new Function()`      |
+| 🎯 **Hybrid Router**          | O(1) static + O(log n) Trie routing                        |
+| 🔌 **Plugin System**          | Fastify-style `register()` with encapsulation              |
+| 🎨 **Decorators**             | Extend app, request, and response                          |
+| ⚡ **Cluster Mode**           | Built-in multi-process scaling                             |
+| 💾 **LRU Cache**              | Built-in response caching with ETag                        |
+| 🔗 **Connection Pool**        | Generic pool for databases                                 |
+| 📂 **File Uploads**           | Multipart uploads with size/type validation                |
+| 🌊 **Streaming**              | Large file uploads without buffering                       |
+| 🔒 **Security**               | Path traversal protection, body limits, error sanitization |
+| 🔄 **Express Adapter**        | Use any Express middleware with `adapt()`                  |
 
 ---
 
@@ -520,6 +512,7 @@ app.get(
 **Benefits:**
 
 - ✅ 2-3x faster JSON serialization
+- ✅ Zero-loop code generation via `new Function()`
 - ✅ No `Object.keys()` enumeration
 - ✅ Zero runtime type checking
 - ✅ Completely optional (routes work without schemas)
@@ -633,14 +626,15 @@ Run benchmarks yourself:
 npm run benchmark
 ```
 
-Tested with 5,000 requests, 50 concurrency:
+Tested under overload (20,000 requests × 200 concurrent):
 
 ```
 Framework    | JSON RPS    | vs Express | vs Fastify
 -------------|-------------|------------|------------
-Vibe         | 14,687      | 2.2x ✅    | 1.3x ✅
-Fastify      | 11,289      | 1.7x       | baseline
-Express      | 6,629       | baseline   | 0.6x
+Vibe         | 11,472      | 4.7x ✅    | 1.01x ✅
+Fastify      | 11,334      | 4.7x       | baseline
+Hono         | 7,351       | 3.0x       | 0.6x
+Express      | 2,421       | baseline   | 0.2x
 ```
 
 ---

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibe-gx",
-  "version": "3.1.0",
+  "version": "4.0.0",
   "description": "A lightweight, high-performance Node.js web framework.",
   "type": "module",
   "main": "vibe.js",

package/utils/core/compile-serializer.js

@@ -1,16 +1,68 @@
 /**
  * Schema-based JSON serializer compiler.
  *
- * Pre-compiles a specialized stringify function from a JSON schema
- * at route registration time. The generated function knows the exact
- * object shape, avoiding Object.keys() enumeration and type-checking
- * at request time.
+ * Uses `new Function()` code generation to produce zero-loop,
+ * straight-line serializer functions from JSON schemas.
+ * Each generated function directly accesses known properties
+ * by name — no loops, no dynamic dispatch, no Object.keys().
+ *
+ * This is the same technique used by Fastify's fast-json-stringify.
  *
  * @module compile-serializer
  */
 
 /**
- * Compiles a JSON schema into a specialized serializer function.
+ * Escapes a string for JSON output.
+ * Handles: " \ \b \f \n \r \t and control chars.
+ * This function is passed into generated serializers.
+ */
+function escapeString(str) {
+  if (str.length === 0) return '""';
+
+  let result = '"';
+  let last = 0;
+
+  for (let i = 0; i < str.length; i++) {
+    const code = str.charCodeAt(i);
+    if (code < 32 || code === 34 || code === 92) {
+      if (i > last) result += str.slice(last, i);
+      switch (code) {
+        case 34:
+          result += '\\"';
+          break;
+        case 92:
+          result += "\\\\";
+          break;
+        case 8:
+          result += "\\b";
+          break;
+        case 12:
+          result += "\\f";
+          break;
+        case 10:
+          result += "\\n";
+          break;
+        case 13:
+          result += "\\r";
+          break;
+        case 9:
+          result += "\\t";
+          break;
+        default:
+          result += "\\u" + code.toString(16).padStart(4, "0");
+      }
+      last = i + 1;
+    }
+  }
+
+  if (last === 0) return '"' + str + '"';
+  if (last < str.length) result += str.slice(last);
+  return result + '"';
+}
+
+/**
+ * Compiles a JSON schema into a specialized serializer function
+ * using code generation for maximum V8 optimization.
  *
  * @param {Object} schema - JSON schema (subset)
  * @returns {(data: any) => string} Compiled serializer
@@ -20,47 +72,144 @@ export function compileSerializer(schema) {
     return JSON.stringify;
   }
 
-  const fn = compileType(schema);
-  return fn;
+  return compileType(schema);
 }
 
 /**
- * Escapes a string for JSON output.
- * Handles: " \ \b \f \n \r \t and control chars
+ * Generates a code-gen serializer for an object schema.
+ * Produces a single straight-line function with no loops.
  */
-const escapeChar = {
-  '"': '\\"',
-  "\\": "\\\\",
-  "\b": "\\b",
-  "\f": "\\f",
-  "\n": "\\n",
-  "\r": "\\r",
-  "\t": "\\t",
-};
+function compileObject(schema) {
+  const props = schema.properties;
+  if (!props) return JSON.stringify;
 
-function escapeString(str) {
-  let result = '"';
-  let last = 0;
+  const keys = Object.keys(props);
+  if (keys.length === 0) return () => "{}";
 
-  for (let i = 0; i < str.length; i++) {
-    const code = str.charCodeAt(i);
-    // Check for characters that need escaping
-    if (code === 34 || code === 92 || code < 32) {
-      const char = str[i];
-      if (i > last) result += str.slice(last, i);
-      result += escapeChar[char] || "\\u" + code.toString(16).padStart(4, "0");
-      last = i + 1;
+  // Build the function body as a single expression
+  const parts = [];
+
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    const prop = props[key];
+    const comma = i > 0 ? "," : "";
+    const jsonKey = `${comma}"${key}":`;
+
+    // Generate inline serialization code per property type
+    parts.push({ key, jsonKey, type: prop.type || "unknown", schema: prop });
+  }
+
+  // Check if all string — ultra-fast codegen path
+  const allSimple = parts.every(
+    (p) =>
+      p.type === "string" ||
+      p.type === "number" ||
+      p.type === "integer" ||
+      p.type === "boolean",
+  );
+
+  if (allSimple && keys.length <= 16) {
+    // Generate a straight-line function via new Function()
+    // This avoids all loops and dynamic dispatch
+    let body = 'if(o===null||o===undefined)return"null";\n';
+    body += "return '{' + ";
+
+    const segments = [];
+    for (let i = 0; i < parts.length; i++) {
+      const p = parts[i];
+      const accessor = `o[${JSON.stringify(p.key)}]`;
+      let valExpr;
+
+      switch (p.type) {
+        case "string":
+          valExpr = `(${accessor}===null||${accessor}===undefined?"null":e(""+${accessor}))`;
+          break;
+        case "number":
+        case "integer":
+          valExpr = `(${accessor}!=${accessor}||${accessor}===1/0||${accessor}===-1/0?"null":""+${accessor})`;
+          break;
+        case "boolean":
+          valExpr = `(${accessor}?"true":"false")`;
+          break;
+      }
+
+      segments.push(`'${p.jsonKey}'+${valExpr}`);
+    }
+
+    body += segments.join("+") + "+'}';";
+
+    try {
+      return new Function("e", "o", body).bind(null, escapeString);
+    } catch {
+      // Fallback if code-gen fails
+      return buildFallbackSerializer(parts);
     }
   }
 
-  if (last === 0) return '"' + str + '"';
-  if (last < str.length) result += str.slice(last);
-  return result + '"';
+  // Complex types (nested objects, arrays) — use pre-compiled sub-serializers
+  return buildComplexSerializer(parts);
+}
+
+/**
+ * Builds a serializer for complex schemas with nested objects/arrays.
+ * Uses pre-compiled child serializers (no code-gen).
+ */
+function buildComplexSerializer(parts) {
+  // Pre-compile child serializers
+  const entries = parts.map((p) => ({
+    key: p.key,
+    jsonKey: p.jsonKey,
+    serializer: compileType(p.schema),
+  }));
+
+  return function serializeComplex(obj) {
+    if (obj === null || obj === undefined) return "null";
+    let result = "{";
+    for (let i = 0; i < entries.length; i++) {
+      const e = entries[i];
+      const v = obj[e.key];
+      result += e.jsonKey;
+      if (v === null || v === undefined) {
+        result += "null";
+      } else {
+        result += e.serializer(v);
+      }
+    }
+    return result + "}";
+  };
+}
+
+/**
+ * Fallback serializer when code-gen fails.
+ */
+function buildFallbackSerializer(parts) {
+  const entries = parts.map((p) => ({
+    key: p.key,
+    jsonKey: p.jsonKey,
+    type: p.type,
+  }));
+
+  return function serializeFallback(obj) {
+    if (obj === null || obj === undefined) return "null";
+    let result = "{";
+    for (let i = 0; i < entries.length; i++) {
+      const e = entries[i];
+      const v = obj[e.key];
+      result += e.jsonKey;
+      if (v === null || v === undefined) {
+        result += "null";
+      } else if (e.type === "string") {
+        result += escapeString("" + v);
+      } else {
+        result += "" + v;
+      }
+    }
+    return result + "}";
+  };
 }
 
 /**
  * Compiles a type-specific serializer from schema.
- * Returns a function (value) => string.
  */
 function compileType(schema) {
   switch (schema.type) {
@@ -83,7 +232,7 @@ function compileType(schema) {
 }
 
 function serializeNumber(v) {
-  if (v !== v || v === Infinity || v === -Infinity) return "null"; // NaN, Inf
+  if (v !== v || v === Infinity || v === -Infinity) return "null";
   return "" + v;
 }
 
@@ -91,63 +240,6 @@ function serializeBoolean(v) {
   return v ? "true" : "false";
 }
 
-/**
- * Compiles an object serializer from schema.properties.
- *
- * Generates a function that directly accesses known properties
- * by name, avoiding Object.keys() enumeration entirely.
- */
-function compileObject(schema) {
-  const props = schema.properties;
-  if (!props) return JSON.stringify;
-
-  const keys = Object.keys(props);
-  if (keys.length === 0) return () => "{}";
-
-  // Pre-compute property serializers and JSON key prefixes
-  const entries = keys.map((key, i) => {
-    const serializer = compileType(props[key]);
-    // Pre-stringify the key + colon (and comma for non-first)
-    const prefix = (i > 0 ? "," : "") + '"' + key + '":';
-    return { key, serializer, prefix };
-  });
-
-  // Check if all properties are simple strings — ultra-fast path
-  const allStrings = keys.every((k) => props[k].type === "string");
-
-  if (allStrings && keys.length <= 8) {
-    // Ultra-fast path for small all-string objects (most common API response)
-    return function serializeStringObject(obj) {
-      if (obj === null || obj === undefined) return "null";
-      let result = "{";
-      for (let i = 0; i < entries.length; i++) {
-        const e = entries[i];
-        const v = obj[e.key];
-        result += e.prefix;
-        result += v === undefined || v === null ? "null" : escapeString("" + v);
-      }
-      return result + "}";
-    };
-  }
-
-  // General path for mixed-type objects
-  return function serializeObject(obj) {
-    if (obj === null || obj === undefined) return "null";
-    let result = "{";
-    for (let i = 0; i < entries.length; i++) {
-      const e = entries[i];
-      const v = obj[e.key];
-      result += e.prefix;
-      if (v === undefined || v === null) {
-        result += "null";
-      } else {
-        result += e.serializer(v);
-      }
-    }
-    return result + "}";
-  };
-}
-
 /**
  * Compiles an array serializer from schema.items.
  */
@@ -158,10 +250,11 @@ function compileArray(schema) {
 
   return function serializeArray(arr) {
     if (!Array.isArray(arr)) return "null";
-    if (arr.length === 0) return "[]";
+    const len = arr.length;
+    if (len === 0) return "[]";
 
     let result = "[" + itemSerializer(arr[0]);
-    for (let i = 1; i < arr.length; i++) {
+    for (let i = 1; i < len; i++) {
       result += "," + itemSerializer(arr[i]);
     }
     return result + "]";

package/utils/core/response.js

@@ -2,6 +2,11 @@ import fs from "fs";
 import path from "path";
 import { mimeTypes } from "../helpers/mime.js";
 
+// Pre-allocated headers (avoid per-request object creation)
+const JSON_CT = { "content-type": "application/json" };
+const TEXT_CT = { "content-type": "text/plain" };
+const HTML_CT = { "Content-Type": "text/html" };
+
 // Pre-allocated response templates (stringified once at startup)
 const RESPONSES = {
   notFound: JSON.stringify({ success: false, message: "Resource not found" }),
@@ -31,12 +36,12 @@ const vibeResponseMethods = {
     }
 
     if (typeof data === "object" && data !== null) {
-      this.setHeader("Content-Type", "application/json");
+      if (!this.headersSent) this.writeHead(this.statusCode || 200, JSON_CT);
       this.end(JSON.stringify(data));
       return;
     }
 
-    this.setHeader("Content-Type", "text/plain");
+    if (!this.headersSent) this.writeHead(this.statusCode || 200, TEXT_CT);
     this.end(String(data));
   },
 
@@ -45,7 +50,7 @@ const vibeResponseMethods = {
    * @param {Object} data
    */
   json(data) {
-    this.setHeader("Content-Type", "application/json");
+    if (!this.headersSent) this.writeHead(this.statusCode || 200, JSON_CT);
     this.end(JSON.stringify(data));
   },
 
@@ -146,8 +151,7 @@ const vibeResponseMethods = {
    * @param {string} message
    */
   success(data = null, message = "Success") {
-    this.statusCode = 200;
-    this.setHeader("Content-Type", "application/json");
+    this.writeHead(200, JSON_CT);
     this.end(JSON.stringify({ success: true, message, data }));
   },
 
@@ -157,8 +161,7 @@ const vibeResponseMethods = {
    * @param {string} message
    */
   created(data = null, message = "Resource created") {
-    this.statusCode = 201;
-    this.setHeader("Content-Type", "application/json");
+    this.writeHead(201, JSON_CT);
     this.end(JSON.stringify({ success: true, message, data }));
   },
 
@@ -168,8 +171,7 @@ const vibeResponseMethods = {
    * @param {any} errors
    */
   badRequest(message = "Bad Request", errors = null) {
-    this.statusCode = 400;
-    this.setHeader("Content-Type", "application/json");
+    this.writeHead(400, JSON_CT);
     this.end(
       errors
         ? JSON.stringify({ success: false, message, errors })
@@ -182,8 +184,7 @@ const vibeResponseMethods = {
    * @param {string} message
    */
   unauthorized(message) {
-    this.statusCode = 401;
-    this.setHeader("Content-Type", "application/json");
+    this.writeHead(401, JSON_CT);
     this.end(
       message
         ? JSON.stringify({ success: false, message })
@@ -196,8 +197,7 @@ const vibeResponseMethods = {
    * @param {string} message
    */
   forbidden(message) {
-    this.statusCode = 403;
-    this.setHeader("Content-Type", "application/json");
+    this.writeHead(403, JSON_CT);
     this.end(
       message
         ? JSON.stringify({ success: false, message })
@@ -210,8 +210,7 @@ const vibeResponseMethods = {
    * @param {string} message
    */
   notFound(message) {
-    this.statusCode = 404;
-    this.setHeader("Content-Type", "application/json");
+    this.writeHead(404, JSON_CT);
     this.end(
       message
         ? JSON.stringify({ success: false, message })
@@ -224,8 +223,7 @@ const vibeResponseMethods = {
    * @param {string} message
    */
   conflict(message) {
-    this.statusCode = 409;
-    this.setHeader("Content-Type", "application/json");
+    this.writeHead(409, JSON_CT);
     this.end(
       message
         ? JSON.stringify({ success: false, message })
@@ -239,8 +237,7 @@ const vibeResponseMethods = {
    */
   serverError(error) {
     console.error(error);
-    this.statusCode = 500;
-    this.setHeader("Content-Type", "application/json");
+    this.writeHead(500, JSON_CT);
     this.end(RESPONSES.serverError);
   },
 

package/utils/core/server.js

@@ -1,19 +1,20 @@
 import http from "http";
-import {
-  error,
-  getNetworkIP,
-  handleError,
-  isSendAble,
-  matchPath,
-} from "./handler.js";
+import { error, getNetworkIP, handleError, isSendAble } from "./handler.js";
 import bodyParser from "./parser.js";
 import { installResponseMethods, initResponse } from "./response.js";
 import dns from "node:dns/promises";
 import { parseQuery } from "../native.js";
 
+// Pre-allocated headers (frozen for V8 optimization)
+const JSON_HEADERS = { "content-type": "application/json" };
+const TEXT_HEADERS = { "content-type": "text/plain" };
+
 // Pre-allocated 404 response
 const NOT_FOUND_BODY = "Not Found";
 
+// Shared frozen empty params (avoids per-request object allocation)
+const EMPTY_PARAMS = Object.freeze(Object.create(null));
+
 /**
  * Creates and starts the Vibe HTTP server.
  * HEAVILY OPTIMIZED for performance
@@ -22,6 +23,20 @@ async function server(options, port, host, callback) {
   // Install response methods on prototype ONCE (zero per-request cost)
   installResponseMethods(http.ServerResponse);
 
+  // Install lazy query getter on IncomingMessage prototype ONCE
+  if (!http.IncomingMessage.prototype._vibeQueryInstalled) {
+    Object.defineProperty(http.IncomingMessage.prototype, "query", {
+      get() {
+        if (this._parsedQuery !== undefined) return this._parsedQuery;
+        this._parsedQuery =
+          this._qIdx < 0 ? {} : parseQuery(this._rawUrl.slice(this._qIdx + 1));
+        return this._parsedQuery;
+      },
+      configurable: true,
+    });
+    http.IncomingMessage.prototype._vibeQueryInstalled = true;
+  }
+
   // Pre-compute everything we can
   const useTrieMatching = options.routeCount > options.trieThreshold;
   const staticRoutes = options.staticRoutes || new Map();
@@ -73,29 +88,22 @@ async function server(options, port, host, callback) {
     return null;
   }
 
-  // Main request handler - OPTIMIZED
+  // Main request handler - ULTRA OPTIMIZED
   function reqListener(req, res) {
     // Fast pathname extraction
     const url = req.url;
     const qIdx = url.indexOf("?");
     const pathname = qIdx < 0 ? url : url.slice(0, qIdx);
 
-    // Lazy query via Object.defineProperty (replaces deprecated __defineGetter__)
-    let _query;
-    Object.defineProperty(req, "query", {
-      get() {
-        if (_query === undefined) {
-          _query = qIdx < 0 ? {} : parseQuery(url.slice(qIdx + 1));
-        }
-        return _query;
-      },
-      configurable: true,
-    });
+    // Store raw values for lazy query parsing (prototype getter handles the rest)
+    req._qIdx = qIdx;
+    req._rawUrl = url;
+    req._parsedQuery = undefined;
 
     req.url = pathname;
 
     // Stamp response with options ref (ONLY per-request cost for response methods)
-    initResponse(res, options);
+    res._vibeOptions = options;
 
     // Apply decorators (only if exist)
     if (requestDecoratorEntries) {
@@ -117,41 +125,44 @@ async function server(options, port, host, callback) {
       const staticMatch = staticRoutes.get(routeKey);
 
       if (staticMatch && !staticMatch.intercept) {
-        const { handler, serialize } = staticMatch;
-        req.params = {};
+        req.params = EMPTY_PARAMS;
+
+        // Pre-built response (string/object/number/boolean registered at route time)
+        if (staticMatch._handlerType === 2) {
+          const pb = staticMatch._prebuilt;
+          // Check if it looks like JSON (starts with { or [)
+          const c = pb.charCodeAt(0);
+          if (c === 123 || c === 91) {
+            res.writeHead(200, JSON_HEADERS);
+          } else {
+            res.writeHead(200, TEXT_HEADERS);
+          }
+          res.end(pb);
+          return;
+        }
+
+        // Function handler
+        const handler = staticMatch.handler;
+        const serialize = staticMatch.serialize;
 
         try {
-          if (typeof handler === "function") {
-            const result = handler(req, res);
-            // Check if handler returned a Promise (async handler)
-            if (result !== undefined && !res.writableEnded) {
-              if (result && typeof result.then === "function") {
-                // Async handler — fall through to async path
-                result
-                  .then((val) => {
-                    if (val !== undefined && !res.writableEnded) {
-                      if (serialize) {
-                        res.setHeader("Content-Type", "application/json");
-                        res.end(serialize(val));
-                      } else {
-                        res.json(val);
-                      }
-                    }
-                  })
-                  .catch((err) => handleError(err, req, res));
-              } else if (serialize) {
-                res.setHeader("Content-Type", "application/json");
-                res.end(serialize(result));
-              } else {
-                res.json(result);
-              }
-            }
-          } else if (isSendAble(handler)) {
-            if (serialize && typeof handler === "object" && handler !== null) {
-              res.setHeader("Content-Type", "application/json");
-              res.end(serialize(handler));
+          const result = handler(req, res);
+          if (result !== undefined && !res.writableEnded) {
+            if (result && typeof result.then === "function") {
+              result
+                .then((val) => {
+                  if (val !== undefined && !res.writableEnded) {
+                    res.writeHead(200, JSON_HEADERS);
+                    res.end(serialize ? serialize(val) : JSON.stringify(val));
+                  }
+                })
+                .catch((err) => handleError(err, req, res));
+            } else if (typeof result === "object" && result !== null) {
+              res.writeHead(200, JSON_HEADERS);
+              res.end(serialize ? serialize(result) : JSON.stringify(result));
             } else {
-              res.send(handler);
+              res.writeHead(200, TEXT_HEADERS);
+              res.end(String(result));
             }
           }
         } catch (err) {
@@ -190,7 +201,7 @@ async function server(options, port, host, callback) {
     }
 
     if (!match) {
-      res.writeHead(404, { "content-type": "text/plain" });
+      res.writeHead(404, TEXT_HEADERS);
       res.end(NOT_FOUND_BODY);
       return;
     }
@@ -218,15 +229,16 @@ async function server(options, port, host, callback) {
         if (result !== undefined && !res.writableEnded) {
           if (serialize) {
             // Pre-compiled schema serializer — fastest path
-            res.setHeader("Content-Type", "application/json");
+            res.writeHead(200, JSON_HEADERS);
             res.end(serialize(result));
           } else {
-            res.json(result);
+            res.writeHead(200, JSON_HEADERS);
+            res.end(JSON.stringify(result));
           }
         }
       } else if (isSendAble(handler)) {
         if (serialize && typeof handler === "object" && handler !== null) {
-          res.setHeader("Content-Type", "application/json");
+          res.writeHead(200, JSON_HEADERS);
           res.end(serialize(handler));
         } else {
           res.send(handler);

package/vibe.d.ts

@@ -51,6 +51,62 @@ export interface MediaOptions {
   streaming?: boolean;
 }
 
+/**
+ * JSON Schema property definition for schema-based serialization.
+ */
+export interface JsonSchemaProperty {
+  /** The type of the property */
+  type:
+    | "string"
+    | "number"
+    | "integer"
+    | "boolean"
+    | "object"
+    | "array"
+    | "null";
+  /** Nested properties (for type: "object") */
+  properties?: Record<string, JsonSchemaProperty>;
+  /** Item schema (for type: "array") */
+  items?: JsonSchemaProperty;
+}
+
+/**
+ * JSON Schema definition for response serialization.
+ *
+ * @example
+ * {
+ *   type: "object",
+ *   properties: {
+ *     id: { type: "number" },
+ *     name: { type: "string" },
+ *     active: { type: "boolean" }
+ *   }
+ * }
+ */
+export interface JsonSchema extends JsonSchemaProperty {
+  type: "object" | "array";
+}
+
+/**
+ * Schema options for a route.
+ * Used for pre-compiled response serialization (2-3x faster than JSON.stringify).
+ *
+ * @example
+ * {
+ *   response: {
+ *     type: "object",
+ *     properties: {
+ *       id: { type: "number" },
+ *       name: { type: "string" }
+ *     }
+ *   }
+ * }
+ */
+export interface SchemaOptions {
+  /** Response schema for pre-compiled JSON serialization */
+  response?: JsonSchema;
+}
+
 /**
  * Options for registering a route.
  *
@@ -88,6 +144,22 @@ export interface RouteOptions {
    * Files will be available in req.files array.
    */
   media?: MediaOptions;
+  /**
+   * JSON Schema for pre-compiled response serialization.
+   * Generates a zero-overhead serializer at route registration time.
+   *
+   * @example
+   * schema: {
+   *   response: {
+   *     type: "object",
+   *     properties: {
+   *       id: { type: "number" },
+   *       name: { type: "string" }
+   *     }
+   *   }
+   * }
+   */
+  schema?: SchemaOptions;
 }
 
 /**

package/vibe.js

@@ -85,6 +85,7 @@ function pathToRegex(path) {
  * @typedef {Object} RouteOptions
  * @property {Interceptor | Interceptor[]} [intercept]
  * @property {MediaOptions} [media]
+ * @property {{ response?: Object }} [schema] Schema for pre-compiled serialization
  */
 
 /**
@@ -92,9 +93,14 @@ function pathToRegex(path) {
  * @typedef {Object} VibeRoute
  * @property {string} method
  * @property {string} path
+ * @property {RegExp | null} pathRegex
  * @property {Handler | string | number | object} handler
  * @property {Interceptor | Interceptor[] | null} intercept
- * @property {MediaOptions} media
+ * @property {((data: any) => string) | null} serialize
+ * @property {MediaOptions | null} media
+ * @property {boolean} [isStatic]
+ * @property {number} [_handlerType]
+ * @property {string | null} [_prebuilt]
  */
 
 /**
@@ -198,6 +204,9 @@ const vibe = () => {
       intercept: null,
       serialize: null,
       media: null, // Only set when explicitly configured
+      // Pre-computed handler metadata (avoids typeof checks on hot path)
+      _handlerType: 0, // 0=unknown, 1=function, 2=prebuilt-string
+      _prebuilt: null, // Pre-stringified response for static handlers
     };
 
     // Handle overriding root route
@@ -227,6 +236,7 @@ const vibe = () => {
       }
       route.pathRegex = /^\/$/;
       route.isStatic = true;
+      finalizeRoute(route);
       trie.insert(method, "/", route);
       staticRoutes.set(method + "/", route);
       // Update existing root route in routes array
@@ -270,6 +280,9 @@ const vibe = () => {
     const isStatic = !fullPath.includes(":") && !fullPath.includes("*");
     route.isStatic = isStatic;
 
+    // Pre-compute handler type for fast-path dispatch
+    finalizeRoute(route);
+
     // Add to static routes Map for O(1) lookup
     if (isStatic) {
       staticRoutes.set(method + fullPath, route);
@@ -281,6 +294,28 @@ const vibe = () => {
     options.routeCount++;
   }
 
+  /**
+   * Pre-computes handler type and pre-stringifies static values.
+   * This moves work from request-time to registration-time.
+   */
+  function finalizeRoute(route) {
+    const h = route.handler;
+    if (typeof h === "function") {
+      route._handlerType = 1; // function
+    } else if (typeof h === "string") {
+      route._handlerType = 2; // pre-built string
+      route._prebuilt = h;
+    } else if (typeof h === "object" && h !== null) {
+      route._handlerType = 2; // pre-built JSON
+      route._prebuilt = route.serialize
+        ? route.serialize(h)
+        : JSON.stringify(h);
+    } else if (typeof h === "number" || typeof h === "boolean") {
+      route._handlerType = 2; // pre-built primitive
+      route._prebuilt = String(h);
+    }
+  }
+
   /**
    * Wraps interceptors with adapt() for consistent behavior
    * @param {Interceptor | Interceptor[]} intercept
@@ -492,6 +527,8 @@ const vibe = () => {
       media: { public: true, dest: null },
     };
     trie.insert("GET", routePath, route);
+    routes.push(route);
+    options.routeCount++;
   }
 
   /**