@velox0/cerver 0.6.4-nightly.20260605.13 → 0.6.4

package/README.md

@@ -148,16 +148,39 @@ Cerver supports a strict, synchronous subset of JavaScript suitable for C code g
 - `for` loops (`for (init; condition; update)`) and `while` loops
 - `const` / `let` variable declarations
 - String and Number literals
-- Template literals
-- Basic comparisons (`===`, `!==`, `<`, `>`)
+- Template literals (`` `Hello ${name}` ``)
+- Basic comparisons (`===`, `!==`, `<`, `>`, `<=`, `>=`)
+- Arithmetic operators (`+`, `-`, `*`, `/`, `%`) on numeric values
+- String concatenation with `+` when at least one operand is a known-string variable (auto-rewritten to a safe `snprintf` buffer)
 - Outbound API calls via `fetch(url, options)`
 
+### String Methods
+
+The following `String.prototype` methods compile to native C:
+
+| Method | Return | C equivalent |
+|---|---|---|
+| `s.toLowerCase()` | `string` | `cerver_str_tolower(s)` |
+| `s.toUpperCase()` | `string` | `cerver_str_toupper(s)` |
+| `s.trim()` | `string` | `cerver_str_trim(s)` |
+| `s.slice(start, end)` | `string` | `cerver_str_slice(s, start, end)` |
+| `s.replace(needle, replacement)` | `string` | `cerver_str_replace(s, needle, replacement)` |
+| `s.concat(a, b, ...)` | `string` | `snprintf` (same path as template literals) |
+| `s.includes(needle)` | `boolean` (int) | `strstr(s, needle) != NULL` |
+| `s.startsWith(prefix)` | `boolean` (int) | `strncmp(s, prefix, strlen(prefix)) == 0` |
+| `s.endsWith(suffix)` | `boolean` (int) | `cerver_str_endswith(s, suffix)` |
+| `s.indexOf(needle)` | `number` (int) | `cerver_str_indexof(s, needle)` |
+| `s.length` | `number` (int) | `(int)strlen(s)` |
+
+String-returning methods (`toLowerCase`, `toUpperCase`, `trim`, `slice`, `replace`, `concat`) must be used as a direct variable initializer or return value — not nested inside a larger expression — because they allocate a heap buffer.
+
 **Not Supported (Compile-Time Errors):**
 
 - `async`/`await` and Promises
 - Classes and the `new` keyword
 - `eval()`
 - Runtime `import`/`require`
+- String concatenation with `+` where both operands are string literals (use template literals instead)
 
 ## Configuration
 
@@ -176,7 +199,14 @@ export default {
 
 1. **Parser**: Uses Acorn to parse your JS route files into ASTs.
 2. **Validator**: Scans the AST to ensure no unsupported JS features are used.
-3. **IR**: Transforms the AST into an Intermediate Representation.
+3. **IR**: Transforms the AST into an Intermediate Representation. Includes a symbol table that tracks variable types for correct `+` operator coercion.
 4. **Generator**: Emits optimized C code mapping directly to your JS logic.
 5. **Asset Pipeline**: Scans the `public/` folder, minifies files, and converts them to C byte arrays.
 6. **Compiler**: Invokes `gcc` or `clang` to compile the generated code and the Cerver runtime into a native binary.
+
+## Known Limitations / Future Work
+
+- `replace()` only replaces the **first** occurrence (like JS). Global replace is not yet supported.
+- String methods that return strings cannot be nested (e.g. `s.trim().toLowerCase()` is not supported — store the intermediate in a variable).
+- The `+` type inference is forward-only; if a variable's type changes via reassignment the inferred type may be stale.
+- `slice()` operates on bytes, not Unicode code points.

package/lib/codegen/emit.js

@@ -133,6 +133,13 @@ function emitExpression(expr) {
       return expr.prefix ? `(${op}${expr.name})` : `(${expr.name}${op})`;
     }
 
+    case "Arithmetic": {
+      /* Numeric C arithmetic — both sides are known numeric */
+      const left = emitExpression(expr.left);
+      const right = emitExpression(expr.right);
+      return `(${left} ${expr.operator} ${right})`;
+    }
+
     case "Concat": {
       /* Interpolated template literals need statement-level snprintf setup. */
       /* This is handled specially in emitStatement when part of a return */
@@ -147,6 +154,20 @@ function emitExpression(expr) {
       );
     }
 
+    case "StringOp": {
+      /*
+       * String-returning ops must be emitted at statement level (need a buffer).
+       * Number-returning ops can be emitted inline.
+       */
+      if (expr.returnType === "number") {
+        return emitStringOpInline(expr);
+      }
+      throw new Error(
+        `cerver: string.${expr.method}() returns a string and must be used as a ` +
+        `direct variable initializer or return value, not inside a larger expression.`,
+      );
+    }
+
     case "Call": {
       /* res.text(status, body) etc. */
       if (expr.object === "res") {
@@ -155,17 +176,6 @@ function emitExpression(expr) {
         return `${fnName}(res, ${args.join(", ")})`;
       }
 
-      /* String method calls — map to C equivalents */
-      if (expr.method === "toLowerCase" || expr.method === "toUpperCase") {
-        /* These would need a helper — for now return the object as-is */
-        return emitExpression(expr.object);
-      }
-      if (expr.method === "includes") {
-        const haystack = emitExpression(expr.object);
-        const needle = expr.args[0] ? emitExpression(expr.args[0]) : '""';
-        return `(strstr(${haystack}, ${needle}) != NULL)`;
-      }
-
       return '""';
     }
 
@@ -315,6 +325,18 @@ function assertInlineExpression(expr) {
     );
   }
 
+  if (
+    containsExpr(
+      expr,
+      (node) => node.type === "StringOp" && node.returnType === "string",
+    )
+  ) {
+    throw new Error(
+      "cerver: string-returning methods (toLowerCase, toUpperCase, trim, slice, replace) " +
+      "are only supported as a direct return value or variable initializer",
+    );
+  }
+
   if (
     containsExpr(
       expr,
@@ -332,10 +354,76 @@ function isNumberFormatExpr(expr) {
     expr &&
     (expr.type === "NumberLiteral" ||
       expr.type === "Comparison" ||
-      expr.type === "Logical")
+      expr.type === "Logical" ||
+      expr.type === "Arithmetic" ||
+      (expr.type === "StringOp" && expr.returnType === "number"))
   );
 }
 
+/**
+ * Emit a number-returning string operation inline (safe for expression context).
+ * Covers: includes, startsWith, endsWith, indexOf, length.
+ */
+function emitStringOpInline(expr) {
+  const obj = emitExpression(expr.object);
+  const arg0 = expr.args[0] ? emitExpression(expr.args[0]) : '""';
+  const arg1 = expr.args[1] ? emitExpression(expr.args[1]) : null;
+
+  switch (expr.method) {
+    case "includes":
+      return `(strstr(${obj}, ${arg0}) != NULL)`;
+
+    case "startsWith":
+      return `(strncmp(${obj}, ${arg0}, strlen(${arg0})) == 0)`;
+
+    case "endsWith":
+      return `cerver_str_endswith(${obj}, ${arg0})`;
+
+    case "indexOf":
+      return `cerver_str_indexof(${obj}, ${arg0})`;
+
+    case "length":
+      return `((int)strlen(${obj}))`;
+
+    default:
+      return "0";
+  }
+}
+
+/**
+ * Emit a heap-allocated string op result into a named buffer.
+ * Covers: toLowerCase, toUpperCase, trim, slice, replace.
+ * Returns lines of C code; varName receives the result pointer.
+ */
+function emitStringOpBlock(expr, pad, varName) {
+  const obj = emitExpression(expr.object);
+  const arg0 = expr.args[0] ? emitExpression(expr.args[0]) : null;
+  const arg1 = expr.args[1] ? emitExpression(expr.args[1]) : null;
+
+  let call;
+  switch (expr.method) {
+    case "toLowerCase":
+      call = `cerver_str_tolower(${obj})`;
+      break;
+    case "toUpperCase":
+      call = `cerver_str_toupper(${obj})`;
+      break;
+    case "trim":
+      call = `cerver_str_trim(${obj})`;
+      break;
+    case "slice":
+      call = `cerver_str_slice(${obj}, ${arg0 || "0"}, ${arg1 !== null ? arg1 : "-1"})`;
+      break;
+    case "replace":
+      call = `cerver_str_replace(${obj}, ${arg0 || '""'}, ${arg1 || '""'})`;
+      break;
+    default:
+      call = `""` ;
+  }
+
+  return [`${pad}char *${varName} = ${call};`];
+}
+
 /**
  * Emit a heap-backed string buffer for an interpolated template literal.
  * The response writer runs after handlers return, so response-bound strings
@@ -446,6 +534,17 @@ function emitStatement(stmt, level, ctx) {
         lines.push(`${pad}${fnName}(res, ${stmt.status}, ${tempName});`);
         lines.push(`${pad}if (${tempName}_owned) res->_body_owned = 1;`);
         lines.push(`${pad}return;`);
+      } else if (
+        stmt.value &&
+        stmt.value.type === "StringOp" &&
+        stmt.value.returnType === "string"
+      ) {
+        /* Heap-allocated string op (tolower, toupper, trim, slice, replace) */
+        const tempName = `_strop_res_${ctx.concatVarCounter++}`;
+        lines.push(...emitStringOpBlock(stmt.value, pad, tempName));
+        lines.push(`${pad}${fnName}(res, ${stmt.status}, ${tempName} ? ${tempName} : "");`);
+        lines.push(`${pad}if (${tempName}) res->_body_owned = 1;`);
+        lines.push(`${pad}return;`);
       } else {
         assertInlineExpression(stmt.value);
         const valueCode = emitExpression(stmt.value);
@@ -541,6 +640,14 @@ function emitStatement(stmt, level, ctx) {
       ) {
         lines.push(...emitConcatBlock(stmt.initExpr, pad, stmt.name));
         ctx.ownedStrings.add(stmt.name);
+      } else if (
+        stmt.initExpr &&
+        stmt.initExpr.type === "StringOp" &&
+        stmt.initExpr.returnType === "string"
+      ) {
+        /* Heap-allocated string op result stored in a mutable char * */
+        lines.push(...emitStringOpBlock(stmt.initExpr, pad, stmt.name));
+        ctx.ownedStrings.add(stmt.name);
       } else {
         assertInlineExpression(stmt.initExpr);
         const val = emitExpression(stmt.initExpr);

package/lib/ir/transform.js

@@ -2,6 +2,121 @@
 
 const IR = require("./types");
 
+/* ------------------------------------------------------------------ */
+/*  String method metadata                                             */
+/* ------------------------------------------------------------------ */
+
+/**
+ * Supported string methods.
+ * returnType:
+ *   "string"  → heap-allocated result, emitted at statement level
+ *   "number"  → int, safe to emit inline
+ */
+const STRING_METHODS = {
+  toLowerCase:  { returnType: "string", minArgs: 0, maxArgs: 0 },
+  toUpperCase:  { returnType: "string", minArgs: 0, maxArgs: 0 },
+  trim:         { returnType: "string", minArgs: 0, maxArgs: 0 },
+  slice:        { returnType: "string", minArgs: 1, maxArgs: 2 },
+  replace:      { returnType: "string", minArgs: 2, maxArgs: 2 },
+  includes:     { returnType: "number", minArgs: 1, maxArgs: 1 },
+  startsWith:   { returnType: "number", minArgs: 1, maxArgs: 1 },
+  endsWith:     { returnType: "number", minArgs: 1, maxArgs: 1 },
+  indexOf:      { returnType: "number", minArgs: 1, maxArgs: 1 },
+};
+
+/* ------------------------------------------------------------------ */
+/*  Type inference helpers                                             */
+/* ------------------------------------------------------------------ */
+
+/**
+ * Infer the C type of an IR expression.
+ * Returns "string" | "number" | "unknown".
+ * The symbol table (Map<name, type>) is threaded through ctx.types.
+ */
+function inferIRType(expr, types) {
+  if (!expr) return "string";
+
+  switch (expr.type) {
+    case "StringLiteral":
+    case "ParamAccess":
+    case "QueryAccess":
+    case "HeaderAccess":
+    case "RequestField":
+    case "Concat":
+      return "string";
+
+    case "NumberLiteral":
+      return "number";
+
+    case "Comparison":
+    case "Logical":
+    case "Arithmetic":
+      return "number";
+
+    case "Unary":
+      return expr.operator === "!" || expr.operator === "-" ? "number" : "string";
+
+    case "Conditional": {
+      const c = inferIRType(expr.consequent, types);
+      const a = inferIRType(expr.alternate, types);
+      return c === "number" && a === "number" ? "number" : "string";
+    }
+
+    case "Identifier":
+      return types && types.has(expr.name) ? types.get(expr.name) : "unknown";
+
+    case "StringOp":
+      return expr.returnType;
+
+    case "Call":
+      /* fetch result is a string */
+      return "string";
+
+    case "Fetch":
+      return "string";
+
+    default:
+      return "unknown";
+  }
+}
+
+/**
+ * Quick check: is an AST node provably numeric at transform time?
+ * Used by transformBinaryExpression to decide before the symbol table.
+ */
+function isNumericAST(node) {
+  if (!node) return false;
+  if (node.type === "Literal" && typeof node.value === "number") return true;
+  if (
+    node.type === "BinaryExpression" &&
+    ["+", "-", "*", "/", "%"].includes(node.operator) &&
+    !(node.type === "BinaryExpression" &&
+      ["===", "!==", "==", "!=", "<", ">", "<=", ">="].includes(node.operator))
+  ) {
+    return isNumericAST(node.left) && isNumericAST(node.right);
+  }
+  if (node.type === "UnaryExpression" && node.operator === "-") {
+    return isNumericAST(node.argument);
+  }
+  return false;
+}
+
+/**
+ * Quick check: is an AST node provably string at transform time?
+ */
+function isStringAST(node) {
+  if (!node) return false;
+  if (node.type === "Literal" && typeof node.value === "string") return true;
+  if (node.type === "TemplateLiteral") return true;
+  /* Member expressions like req.params.x, req.query.x are always strings */
+  if (node.type === "MemberExpression") return true;
+  return false;
+}
+
+/* ------------------------------------------------------------------ */
+/*  Top-level file transform                                           */
+/* ------------------------------------------------------------------ */
+
 /**
  * Transform a validated AST into an IR route descriptor.
  *
@@ -39,8 +154,12 @@ function transformFile(ast, urlPath) {
           ? funcDecl.params[1].name
           : "res";
 
-      /* Transform the function body */
-      const ctx = { reqName, resName };
+      /*
+       * ctx carries:
+       *   reqName, resName — parameter names in scope
+       *   types           — symbol table: Map<varName, "string"|"number">
+       */
+      const ctx = { reqName, resName, types: new Map() };
       const { variables, body } = transformBlock(funcDecl.body, ctx, {
         hoistVariables: true,
       });
@@ -53,6 +172,10 @@ function transformFile(ast, urlPath) {
   return routes;
 }
 
+/* ------------------------------------------------------------------ */
+/*  Block / statement transform                                        */
+/* ------------------------------------------------------------------ */
+
 /**
  * Transform a block statement into IR variables and statements.
  */
@@ -105,6 +228,10 @@ function transformStatement(node, ctx, options) {
   }
 }
 
+/* ------------------------------------------------------------------ */
+/*  Statement-level transforms                                         */
+/* ------------------------------------------------------------------ */
+
 /**
  * Transform a return statement.
  *
@@ -230,6 +357,7 @@ function transformFor(node, ctx) {
 
 /**
  * Transform a variable declaration.
+ * Registers the inferred type in ctx.types for later use.
  */
 function transformVariableDecl(node, ctx) {
   /* For simplicity, handle the first declarator */
@@ -241,37 +369,19 @@ function transformVariableDecl(node, ctx) {
     ? transformExpression(decl.init, ctx)
     : IR.IRStringLiteral("");
 
-  const valueType = inferValueType(initExpr);
-
-  return IR.IRVariable(name, valueType, initExpr);
-}
-
-function inferValueType(expr) {
-  if (!expr) return "string";
-
-  if (
-    expr.type === "NumberLiteral" ||
-    expr.type === "Comparison" ||
-    expr.type === "Logical"
-  ) {
-    return "number";
-  }
+  const valueType = inferIRType(initExpr, ctx.types);
+  const resolvedType = valueType === "unknown" ? "string" : valueType;
 
-  if (expr.type === "Unary") {
-    return expr.operator === "!" || expr.operator === "-" ? "number" : "string";
-  }
+  /* Register so subsequent expressions can look up this variable's type */
+  ctx.types.set(name, resolvedType);
 
-  if (expr.type === "Conditional") {
-    const consequentType = inferValueType(expr.consequent);
-    const alternateType = inferValueType(expr.alternate);
-    return consequentType === "number" && alternateType === "number"
-      ? "number"
-      : "string";
-  }
-
-  return "string";
+  return IR.IRVariable(name, resolvedType, initExpr);
 }
 
+/* ------------------------------------------------------------------ */
+/*  Expression transform                                               */
+/* ------------------------------------------------------------------ */
+
 /**
  * Transform an expression into an IR expression node.
  */
@@ -287,11 +397,7 @@ function transformExpression(node, ctx) {
       return IR.IRIdentifier(node.name);
 
     case "BinaryExpression":
-      return IR.IRComparison(
-        node.operator,
-        transformExpression(node.left, ctx),
-        transformExpression(node.right, ctx),
-      );
+      return transformBinaryExpression(node, ctx);
 
     case "LogicalExpression":
       return IR.IRLogical(
@@ -330,11 +436,116 @@ function transformExpression(node, ctx) {
   }
 }
 
+/**
+ * Helper to flatten nested Concat nodes and merge adjacent StringLiterals.
+ */
+function createConcat(parts) {
+  const flat = [];
+  for (const p of parts) {
+    if (p.type === "Concat") {
+      flat.push(...p.parts);
+    } else {
+      flat.push(p);
+    }
+  }
+  
+  const merged = [];
+  for (const p of flat) {
+    if (p.type === "StringLiteral") {
+      if (merged.length > 0 && merged[merged.length - 1].type === "StringLiteral") {
+        merged[merged.length - 1].value += p.value;
+      } else {
+        merged.push({ ...p });
+      }
+    } else {
+      merged.push(p);
+    }
+  }
+  
+  if (merged.length === 1) return merged[0];
+  return IR.IRConcat(merged);
+}
+
+/* ------------------------------------------------------------------ */
+/*  Binary expression: +, -, *, /, %, comparisons                     */
+/* ------------------------------------------------------------------ */
+
+/**
+ * Transform a binary expression.
+ */
+function transformBinaryExpression(node, ctx) {
+  const arithmeticOps = new Set(["+", "-", "*", "/", "%"]);
+  const comparisonOps = new Set(["===", "!==", "==", "!=", "<", ">", "<=", ">="]);
+
+  if (comparisonOps.has(node.operator)) {
+    return IR.IRComparison(
+      node.operator,
+      transformExpression(node.left, ctx),
+      transformExpression(node.right, ctx),
+    );
+  }
+
+  if (!arithmeticOps.has(node.operator)) {
+    return IR.IRStringLiteral("");
+  }
+
+  if (node.operator !== "+") {
+    return IR.IRArithmetic(
+      node.operator,
+      transformExpression(node.left, ctx),
+      transformExpression(node.right, ctx),
+    );
+  }
+
+  const leftIsNumericAST = isNumericAST(node.left);
+  const rightIsNumericAST = isNumericAST(node.right);
+  const leftIsStringAST = isStringAST(node.left);
+  const rightIsStringAST = isStringAST(node.right);
+
+  const leftIR = transformExpression(node.left, ctx);
+  const rightIR = transformExpression(node.right, ctx);
+
+  const leftType = inferIRType(leftIR, ctx.types);
+  const rightType = inferIRType(rightIR, ctx.types);
+
+  if (
+    (leftIsNumericAST || leftType === "number") &&
+    (rightIsNumericAST || rightType === "number")
+  ) {
+    return IR.IRArithmetic("+", leftIR, rightIR);
+  }
+
+  if (
+    leftIsStringAST || rightIsStringAST ||
+    leftType === "string" || rightType === "string"
+  ) {
+    return createConcat([leftIR, rightIR]);
+  }
+
+  throw new Error(
+    `cerver: '+' with operands of unknown type — cannot determine whether this is ` +
+    `numeric addition or string concatenation. ` +
+    `Declare variables with explicit initial values so the type can be inferred, ` +
+    `or use a template literal (\`...\${expression}...\`) for string concatenation.`,
+  );
+}
+
+/* ------------------------------------------------------------------ */
+/*  Assignment / Update                                                */
+/* ------------------------------------------------------------------ */
+
 function transformAssignmentExpr(node, ctx) {
   if (!node.left || node.left.type !== "Identifier") {
     return IR.IRStringLiteral("");
   }
   const value = transformExpression(node.right, ctx);
+
+  /* Keep the symbol table consistent for += on string variables */
+  if (node.operator === "=" && ctx.types) {
+    const t = inferIRType(value, ctx.types);
+    if (t !== "unknown") ctx.types.set(node.left.name, t);
+  }
+
   return IR.IRAssignment(node.left.name, node.operator, value);
 }
 
@@ -345,6 +556,10 @@ function transformUpdateExpr(node) {
   return IR.IRUpdate(node.argument.name, node.operator, node.prefix);
 }
 
+/* ------------------------------------------------------------------ */
+/*  Member expressions                                                 */
+/* ------------------------------------------------------------------ */
+
 /**
  * Transform member expressions.
  *
@@ -352,6 +567,7 @@ function transformUpdateExpr(node) {
  *   req.params.key  → IRParamAccess("key")
  *   req.query.x     → IRQueryAccess("x")
  *   req.headers.x   → IRHeaderAccess("x")
+ *   str.length      → IRStringOp("length", str, [], "number")
  */
 function transformMemberExpr(node, ctx) {
   /* req.params.key or req.query.key */
@@ -375,9 +591,22 @@ function transformMemberExpr(node, ctx) {
     if (prop === "path") return IR.IRRequestField("path");
   }
 
+  /* str.length — property access, not a call */
+  if (!node.computed) {
+    const prop = node.property.name;
+    if (prop === "length") {
+      const obj = transformExpression(node.object, ctx);
+      return IR.IRStringOp("length", obj, [], "number");
+    }
+  }
+
   return IR.IRStringLiteral("");
 }
 
+/* ------------------------------------------------------------------ */
+/*  Call expressions                                                   */
+/* ------------------------------------------------------------------ */
+
 /**
  * Transform call expressions.
  */
@@ -431,17 +660,44 @@ function transformCallExpr(node, ctx) {
     return IR.IRFetch(urlExpr, methodExpr, bodyExpr, headersArr);
   }
 
-  /* String methods like str.toLowerCase(), includes() etc. — return as-is */
-  if (node.callee.type === "MemberExpression") {
+  /* String method calls: str.toLowerCase(), str.includes(n), etc. */
+  if (
+    node.callee.type === "MemberExpression" &&
+    !node.callee.computed
+  ) {
+    const methodName = node.callee.property.name;
+
+    /* str.concat(a, b, ...) → IRConcat([obj, a, b, ...])
+     * Variadic, same snprintf path as template literals and "+". */
+    if (methodName === "concat") {
+      const obj  = transformExpression(node.callee.object, ctx);
+      const args = node.arguments.map((a) => transformExpression(a, ctx));
+      const parts = [obj, ...args];
+      if (parts.length === 1) return parts[0];
+      return createConcat(parts);
+    }
+
+    const meta = STRING_METHODS[methodName];
+
+    if (meta) {
+      const obj = transformExpression(node.callee.object, ctx);
+      const args = node.arguments.map((a) => transformExpression(a, ctx));
+      return IR.IRStringOp(methodName, obj, args, meta.returnType);
+    }
+
+    /* Generic method call — pass through as IRCall (for res.* etc.) */
     const obj = transformExpression(node.callee.object, ctx);
-    const method = node.callee.property.name;
     const args = node.arguments.map((a) => transformExpression(a, ctx));
-    return IR.IRCall(obj, method, args);
+    return IR.IRCall(obj, methodName, args);
   }
 
   return IR.IRStringLiteral("");
 }
 
+/* ------------------------------------------------------------------ */
+/*  Template literals                                                  */
+/* ------------------------------------------------------------------ */
+
 /**
  * Transform template literals into concatenation.
  */
@@ -459,7 +715,7 @@ function transformTemplateLiteral(node, ctx) {
   }
 
   if (parts.length === 1) return parts[0];
-  return IR.IRConcat(parts);
+  return createConcat(parts);
 }
 
 module.exports = { transformFile };

package/lib/ir/types.js

@@ -267,6 +267,39 @@ function IRFetch(url, method, body, headers) {
   };
 }
 
+/**
+ * A numeric arithmetic expression (+, -, *, /, %).
+ * Distinct from IRComparison (which uses strcmp for strings).
+ * Both operands must be numeric.
+ */
+function IRArithmetic(operator, left, right) {
+  return {
+    type: "Arithmetic",
+    operator /* "+" | "-" | "*" | "/" | "%" */,
+    left /* IRExpression */,
+    right /* IRExpression */,
+  };
+}
+
+/**
+ * A compiled string method call.
+ *
+ * @param {string} method    - The JS method name ("toLowerCase", "includes", etc.)
+ * @param {object} object    - IR expression for the string being operated on
+ * @param {object[]} args    - IR expressions for method arguments
+ * @param {string} returnType - "string" | "number" — drives emit strategy
+ */
+function IRStringOp(method, object, args, returnType) {
+  return {
+    type: "StringOp",
+    method,
+    object,
+    args,
+    returnType /* "string" (heap-alloc) | "number" (inline) */,
+  };
+}
+
+
 module.exports = {
   IRRoute,
   IRHandler,
@@ -291,4 +324,7 @@ module.exports = {
   IRConcat,
   IRCall,
   IRFetch,
+  IRArithmetic,
+  IRStringOp,
 };
+

package/lib/validator/validate.js

@@ -227,6 +227,13 @@ function validate(ast, filePath, source) {
         );
       }
     }
+
+    /*
+     * "+" operator: fully handled by the transform pass's symbol table.
+     * String literal + string literal, identifier + string, numeric + numeric —
+     * all are correctly lowered to IRArithmetic, IRConcat, or a compile-time
+     * error with good diagnostics. Nothing to catch here.
+     */
   });
 
   if (errors.length > 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@velox0/cerver",
-  "version": "0.6.4-nightly.20260605.13",
+  "version": "0.6.4",
   "description": "Compile restricted JavaScript server logic into optimized native C binaries (cross-platform: Linux, macOS, Windows)",
   "main": "bin/cerver.js",
   "bin": {

package/runtime/cerver.h

@@ -282,6 +282,29 @@ void              cerver_trie_free(void* trie);
  */
 char* cerver_fetch(const char* url, const char* method, const char* body, const char** headers);
 
+/* ------------------------------------------------------------------ */
+/*  String operations (generated route code)                          */
+/* ------------------------------------------------------------------ */
+
+/* Case conversion — return malloc'd strings (caller must free) */
+char* cerver_str_tolower(const char* s);
+char* cerver_str_toupper(const char* s);
+
+/* Whitespace removal — returns malloc'd string */
+char* cerver_str_trim(const char* s);
+
+/* Substring — returns malloc'd string; end=-1 means "to end of string" */
+char* cerver_str_slice(const char* s, int start, int end);
+
+/* First-occurrence replace — returns malloc'd string */
+char* cerver_str_replace(const char* s, const char* needle, const char* replacement);
+
+/* Predicate helpers — return int, safe for inline expressions */
+int cerver_str_endswith(const char* s, const char* suffix);
+int cerver_str_indexof(const char* s, const char* needle);
+
+
+
 /* ------------------------------------------------------------------ */
 /*  MIME (internal)                                                   */
 /* ------------------------------------------------------------------ */

package/runtime/static.c

@@ -226,12 +226,24 @@ static int serve_filesystem(cerver_server_t* srv, cerver_request_t* req, cerver_
   char full_path[CERVER_MAX_PATH * 2];
   snprintf(full_path, sizeof(full_path), "%s%s", srv->public_dir, path);
 
+#if CERVER_PLATFORM_WINDOWS
+  /* Normalize forward slashes to backslashes for native Windows APIs */
+  for (char* p = full_path; *p; p++) {
+    if (*p == '/') *p = '\\';
+  }
+#endif
+
   /* Check if it's a directory — try fallback path */
   struct stat st;
   if (stat(full_path, &st) == 0 && S_ISDIR(st.st_mode)) {
     char fallback_path[CERVER_MAX_PATH];
     get_fallback_path(path, fallback_path, sizeof(fallback_path));
     snprintf(full_path, sizeof(full_path), "%s%s", srv->public_dir, fallback_path);
+#if CERVER_PLATFORM_WINDOWS
+    for (char* p = full_path; *p; p++) {
+      if (*p == '/') *p = '\\';
+    }
+#endif
     if (stat(full_path, &st) != 0) return -1;
   }
 

package/runtime/str_ops.c

@@ -0,0 +1,190 @@
+/*
+ * str_ops.c — String operation helpers for cerver generated code.
+ *
+ * These functions provide the C implementations for JavaScript string
+ * methods compiled by cerver. All functions that return strings return
+ * heap-allocated buffers (malloc). Callers are responsible for freeing
+ * the returned pointer — the generated code tracks ownership via the
+ * _body_owned flag on cerver_response_t.
+ *
+ * Functions that return int are safe to call inline.
+ */
+
+#include <ctype.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+
+/* ------------------------------------------------------------------ */
+/*  Case conversion                                                    */
+/* ------------------------------------------------------------------ */
+
+/**
+ * Return a malloc'd copy of `s` with all ASCII characters lowercased.
+ * Returns NULL on allocation failure.
+ */
+char *cerver_str_tolower(const char *s) {
+  if (!s) return NULL;
+  size_t len = strlen(s);
+  char  *out = (char *)malloc(len + 1);
+  if (!out) return NULL;
+  for (size_t i = 0; i <= len; i++) {
+    out[i] = (char)tolower((unsigned char)s[i]);
+  }
+  return out;
+}
+
+/**
+ * Return a malloc'd copy of `s` with all ASCII characters uppercased.
+ * Returns NULL on allocation failure.
+ */
+char *cerver_str_toupper(const char *s) {
+  if (!s) return NULL;
+  size_t len = strlen(s);
+  char  *out = (char *)malloc(len + 1);
+  if (!out) return NULL;
+  for (size_t i = 0; i <= len; i++) {
+    out[i] = (char)toupper((unsigned char)s[i]);
+  }
+  return out;
+}
+
+/* ------------------------------------------------------------------ */
+/*  Trim                                                               */
+/* ------------------------------------------------------------------ */
+
+/**
+ * Return a malloc'd copy of `s` with leading and trailing ASCII
+ * whitespace removed. Returns NULL on allocation failure.
+ */
+char *cerver_str_trim(const char *s) {
+  if (!s) return NULL;
+
+  /* Skip leading whitespace */
+  while (*s && isspace((unsigned char)*s)) s++;
+
+  const char *end = s + strlen(s);
+  /* Skip trailing whitespace */
+  while (end > s && isspace((unsigned char)*(end - 1))) end--;
+
+  size_t len = (size_t)(end - s);
+  char  *out = (char *)malloc(len + 1);
+  if (!out) return NULL;
+  memcpy(out, s, len);
+  out[len] = '\0';
+  return out;
+}
+
+/* ------------------------------------------------------------------ */
+/*  Slice                                                              */
+/* ------------------------------------------------------------------ */
+
+/**
+ * Return a malloc'd substring of `s` from byte index `start` (inclusive)
+ * to `end` (exclusive), mirroring JS Array/String.prototype.slice().
+ *
+ * Negative indices count from the end of the string.
+ * Pass end = -1 to mean "to the end of the string".
+ *
+ * Returns NULL on allocation failure.
+ */
+char *cerver_str_slice(const char *s, int start, int end) {
+  if (!s) return NULL;
+  int len = (int)strlen(s);
+
+  /* Resolve negative indices */
+  if (start < 0) start = len + start;
+  if (end < 0)   end   = (end == -1) ? len : len + end;
+
+  /* Clamp */
+  if (start < 0)   start = 0;
+  if (start > len) start = len;
+  if (end   < 0)   end   = 0;
+  if (end   > len) end   = len;
+  if (start > end) { int t = start; start = end; end = t; }
+
+  int    out_len = end - start;
+  char  *out     = (char *)malloc((size_t)out_len + 1);
+  if (!out) return NULL;
+  memcpy(out, s + start, (size_t)out_len);
+  out[out_len] = '\0';
+  return out;
+}
+
+/* ------------------------------------------------------------------ */
+/*  Replace (first occurrence)                                        */
+/* ------------------------------------------------------------------ */
+
+/**
+ * Return a malloc'd copy of `s` with the first occurrence of `needle`
+ * replaced by `replacement`. If `needle` is not found, returns a copy
+ * of `s`. Returns NULL on allocation failure.
+ */
+char *cerver_str_replace(const char *s, const char *needle,
+                         const char *replacement) {
+  if (!s) return NULL;
+  if (!needle || *needle == '\0') {
+    /* Empty needle — return a copy */
+    size_t len = strlen(s);
+    char  *out = (char *)malloc(len + 1);
+    if (!out) return NULL;
+    memcpy(out, s, len + 1);
+    return out;
+  }
+
+  const char *pos = strstr(s, needle);
+  if (!pos) {
+    /* Needle not found — return a copy of s */
+    size_t len = strlen(s);
+    char  *out = (char *)malloc(len + 1);
+    if (!out) return NULL;
+    memcpy(out, s, len + 1);
+    return out;
+  }
+
+  size_t needle_len      = strlen(needle);
+  size_t replacement_len = replacement ? strlen(replacement) : 0;
+  size_t before_len      = (size_t)(pos - s);
+  size_t after_len       = strlen(pos + needle_len);
+  size_t total           = before_len + replacement_len + after_len + 1;
+
+  char *out = (char *)malloc(total);
+  if (!out) return NULL;
+
+  char *p = out;
+  memcpy(p, s, before_len);
+  p += before_len;
+  if (replacement_len) {
+    memcpy(p, replacement, replacement_len);
+    p += replacement_len;
+  }
+  memcpy(p, pos + needle_len, after_len + 1); /* +1 for NUL */
+  return out;
+}
+
+/* ------------------------------------------------------------------ */
+/*  Predicate helpers (return int, safe for inline expression)        */
+/* ------------------------------------------------------------------ */
+
+/**
+ * Return 1 if `s` ends with `suffix`, 0 otherwise.
+ * Mirrors JS String.prototype.endsWith().
+ */
+int cerver_str_endswith(const char *s, const char *suffix) {
+  if (!s || !suffix) return 0;
+  size_t slen      = strlen(s);
+  size_t suffixlen = strlen(suffix);
+  if (suffixlen > slen) return 0;
+  return memcmp(s + slen - suffixlen, suffix, suffixlen) == 0;
+}
+
+/**
+ * Return the byte index of the first occurrence of `needle` in `s`,
+ * or -1 if not found. Mirrors JS String.prototype.indexOf().
+ */
+int cerver_str_indexof(const char *s, const char *needle) {
+  if (!s || !needle) return -1;
+  const char *pos = strstr(s, needle);
+  if (!pos) return -1;
+  return (int)(pos - s);
+}