vanilla-jet 1.4.0 → 1.4.1

package/CHANGELOG.md

@@ -4,14 +4,25 @@ All notable project changes are documented in this file.
 
 The format follows a structure inspired by Keep a Changelog and semantic versioning.
 
-## [1.4.0] - 2026-02-19
+## [1.4.1] - 2026-02-19
 
-### Highlights
+### Highlights (v1.4.1)
 
-- Added `dev:vite` and `build:vite` scripts to introduce a Vite-first JS/LESS pipeline without removing legacy Gulp commands.
-- Added `vite.config.js` and `.scripts/run_vite.js` to support consumer-root execution, compatibility output in `public/`, and a dev helper route (`/__vanillajet__/`).
-- Added CLI support in `bin.js` for `npx vanilla-jet dev:vite` and `npx vanilla-jet build:vite`.
-- Updated `README.md` to document legacy vs modern workflows for HU 2.1.
+- Completed HU 2.1 (`Fast path de estaticos en Node`).
+- Optimized static serving in `framework/router.js`:
+  - Added warm-path static resolution cache (`route + accept-encoding`) to avoid repeated candidate resolution work.
+  - Added bounded metadata revalidation window for conditional requests to reduce repeated `fs.stat` pressure.
+  - Consolidated static header assembly and reused mime header maps.
+  - Kept stream-based delivery for large assets and tuned `createReadStream` chunk size.
+- Added reproducible local benchmark:
+  - New script: `npm run benchmark:static`.
+  - New guide: `docs/benchmark-static.md`.
+
+### Compatibility notes (v1.4.1)
+
+- No public API changes.
+- Preserves static conditional caching (`304`) and precompressed negotiation fallback.
+- No intended behavior changes for dynamic routes.
 
 ## [1.3.6] - 2026-02-19
 
@@ -92,4 +103,4 @@ The format follows a structure inspired by Keep a Changelog and semantic version
 [1.3.4]: https://github.com/nalancer08/VanillaJet/releases/tag/v1.3.4
 [1.3.5]: https://github.com/nalancer08/VanillaJet/releases/tag/v1.3.5
 [1.3.6]: https://github.com/nalancer08/VanillaJet/releases/tag/v1.3.6
-[1.4.0]: https://github.com/nalancer08/VanillaJet/releases/tag/v1.4.0
+[1.4.1]: https://github.com/nalancer08/VanillaJet/releases/tag/v1.4.1

package/README.md

@@ -6,7 +6,7 @@ Node.js framework for building SPA applications with a JS/CSS/HTML build pipelin
 
 ## Current version
 
-- Version: `1.4.0`
+- Version: `1.4.1`
 - Changelog: see [`CHANGELOG.md`](./CHANGELOG.md)
 - Improvement plan (performance and backward compatibility): see `ROADMAP_INTEGRAL.md`
 
@@ -67,33 +67,17 @@ new Server(Config, [AppEndpoint]).start();
 From this repository:
 
 - `npm run setup`: generates a base `vanillaJet.package.json` if it does not exist.
-- `npm run dev`: legacy Gulp build + watcher for development.
-- `npm run dev:vite`: modern Vite dev server for JS/LESS DX (keeps Nunjucks flow unchanged).
-- `npm run build:vite`: modern Vite build for JS/LESS output in `public/`.
+- `npm run dev`: build + watcher for development.
 - `npm run build:qa`: build for QA.
 - `npm run build:staging`: build for staging.
 - `npm run build:prod`: build for production.
+- `npm run benchmark:static`: runs reproducible static serving benchmark (cold/warm).
 
 As CLI (`bin.js`):
 
 - `npx vanilla-jet setup`
 - `npx vanilla-jet dev`
 - `npx vanilla-jet build`
-- `npx vanilla-jet dev:vite`
-- `npx vanilla-jet build:vite`
-
-## Legacy vs Vite mode
-
-- Legacy (`npm run dev` / `npx vanilla-jet dev`):
-  - Keeps full historical Gulp pipeline (JS minify+concat, LESS, templates, gzip artifacts).
-  - Recommended when you need 100% historical behavior.
-- Vite (`npm run dev:vite` / `npx vanilla-jet dev:vite`):
-  - Focuses on JS/LESS developer experience with faster feedback.
-  - Does not replace Nunjucks compilation in this stage (HU 2.1), so template flow remains legacy.
-  - Dev helper page: open `http://localhost:5173/__vanillajet__/` to load the Vite entry.
-- Vite build (`npm run build:vite` / `npx vanilla-jet build:vite`):
-  - Generates `public/scripts/vanilla.min.js` and `public/styles/app.min.css`.
-  - Keeps existing legacy build commands available and unchanged.
 
 ## Expected consumer project structure
 
@@ -136,9 +120,23 @@ Behavior details:
 - Safe fallback: if `.br` or `.gz` does not exist, server serves the original file.
 - HTML rendering (`response.render`) also uses safe runtime fallback for precompressed templates (`.br`/`.gz`/original).
 
+## Static performance notes (HU 2.1)
+
+Static serving includes a warm-path optimization focused on Node runtime latency:
+
+- Reuses static resolution for repeated requests (`route + accept-encoding`).
+- Reduces repeated metadata refresh with bounded revalidation windows.
+- Keeps streaming strategy for large assets (`fs.createReadStream`) with tuned chunk size.
+- Preserves conditional cache behavior (`ETag`/`Last-Modified` + `304`) and precompressed fallback contract.
+
+Benchmark guide:
+
+- [`docs/benchmark-static.md`](./docs/benchmark-static.md)
+
 ## Additional documentation
 
 - Router: `docs/router.md`
+- Benchmark: [`docs/benchmark-static.md`](./docs/benchmark-static.md)
 - Version history: [`CHANGELOG.md`](./CHANGELOG.md)
 - Roadmap and improvements: `ROADMAP_INTEGRAL.md`
 - Deployment templates (nginx + docker): `docs/deployment/`

package/ROADMAP_INTEGRAL.md

@@ -5,9 +5,9 @@ Cada historia incluye su ciclo completo: fases, tareas, entregables, metricas, c
 
 ## Objetivo
 
-- Modernizar el framework con `Vite` como base de DX.
-- Reducir dependencia de Node para servir frontend.
-- Adoptar `nginx` y Docker al final, con evidencia y sin romper legacy.
+- Maximizar performance de serving estatico sobre Node sin romper compatibilidad.
+- Acelerar el pipeline de compilacion en tiempo real (watch/recompile) para DX diaria.
+- Mejorar flujo `dev` con apertura automatica de navegador y live reload estable.
 
 ## Reglas de ejecucion
 
@@ -115,121 +115,129 @@ Cada historia incluye su ciclo completo: fases, tareas, entregables, metricas, c
 
 ---
 
-## EPIC 2 - Vite first (foco actual)
+## EPIC 2 - Performance Node + DX de compilacion (foco actual)
 
-### HU 2.1 - `dev:vite` y `build:vite` sin romper legacy (completada `v1.4.0`)
+### HU 2.1 - Fast path de estaticos en Node (completada `v1.4.1`)
 
 #### Fases
-- F1: baseline.
-- F2: integrar scripts Vite.
-- F3: coexistencia con legacy.
-- F4: validacion en consumidor real.
+- F1: profiling de request estatico.
+- F2: optimizacion de lectura/respuesta.
+- F3: validacion de no-regresion.
 
 #### Tareas
-- [x] Config Vite (JS/LESS).
-- [x] Mantener Nunjucks en esta etapa.
-- [x] Documentar `dev` legacy vs `dev:vite`.
+- [x] Optimizar resolucion de archivo y headers para evitar trabajo repetido.
+- [x] Revisar estrategia de `fs`/stream para minimizar latencia en assets grandes.
+- [x] Agregar benchmark local reproducible (cold/warm cache).
 
 #### Entregables
-- Config y scripts de Vite.
+- [x] Patch de performance en `framework/router.js`.
+- [x] Script de benchmark local documentado.
 
 #### Metricas
-- Arranque dev >= 40% mas rapido.
-- Rebuild incremental >= 50% mas rapido.
+- p95 de estaticos >= 20% mejor en escenario warm.
+- Menor uso de CPU en serving concurrente.
 
 #### Criterios
-- HMR estable.
-- Legacy intacto.
+- [x] Sin romper cache condicional (`304`) ni negociacion precompressed.
+- [x] Sin impacto en rutas dinamicas.
 
 #### Documentacion
-- `README.md` + `CHANGELOG.md`.
+- [x] `README.md` + `CHANGELOG.md` + guia de benchmark.
 
-### HU 2.2 - Node deja de servir frontend en modo moderno (pendiente)
+### HU 2.2 - Recompile en tiempo real mas rapido (pendiente)
 
 #### Fases
-- F1: contrato `legacy` vs `modern`.
-- F2: flag de transicion.
-- F3: validacion de compatibilidad.
+- F1: baseline de tiempos por tarea de build.
+- F2: optimizacion incremental.
+- F3: validacion en proyecto consumidor.
 
 #### Tareas
-- Node solo API/dinamico en modo moderno.
-- Frontend servido por Vite (dev) y luego Nginx (prod).
+- Reducir trabajo redundante en `gulpfile.js` (globs, minify y concatenacion).
+- Mejorar estrategia de watch para recompilar solo lo tocado.
+- Medir tiempo de recompile por tipo de cambio (JS, LESS, HTML).
 
 #### Entregables
-- Contrato por entorno.
+- Pipeline `dev` optimizado y medido.
 
 #### Metricas
-- Menos carga de static serving en Node.
+- Recompile JS >= 35% mas rapido.
+- Recompile LESS >= 30% mas rapido.
 
 #### Criterios
-- Modo moderno sin dependencia de `response.render()`.
-- Modo legacy intacto.
+- Output final equivalente al flujo actual.
+- Sin cambios obligatorios en estructura de proyectos consumidores.
 
 #### Documentacion
-- Guia de migracion de modo.
+- `README.md` + `CHANGELOG.md`.
 
 ---
 
-## EPIC 3 - Benchmark y decision gate
+## EPIC 3 - Developer Experience en `dev`
 
-### HU 3.1 - Go/No-Go de Nginx basado en datos (pendiente)
+### HU 3.1 - Runner `dev` con navegador auto-open + live reload estable (pendiente)
 
 #### Fases
-- F1: dise;o benchmark A/B.
-- F2: ejecucion.
-- F3: analisis.
-- F4: decision.
+- F1: contrato de ejecucion unificado.
+- F2: implementacion runner.
+- F3: validacion en Mac/Windows/Linux.
 
 #### Tareas
-- Medir p50/p95/p99, throughput, CPU, memoria.
-- Definir umbrales minimos de aprobacion.
+- Abrir navegador automaticamente al iniciar `dev`.
+- Disparar live reload al terminar recompile de assets/templates.
+- Mantener modo fallback para entornos sin navegador.
 
 #### Entregables
-- Reporte benchmark.
-- Decision log Go/No-Go.
+- Nuevo flujo `npm run dev` mas simple para consumidores.
+
+#### Metricas
+- Tiempo a primer render local menor.
+- Menos pasos manuales de arranque en onboarding.
 
 #### Criterios
-- Decision trazable con evidencia.
+- Reload confiable tras cada recompile exitoso.
+- Sin romper el modo actual para usuarios legacy.
 
 #### Documentacion
-- Documento benchmark + resumen tecnico.
+- `README.md` + `CHANGELOG.md` + guia de migracion de scripts.
 
 ---
 
-## EPIC 4 - Adopcion final de infraestructura
+## EPIC 4 - Hardening operativo del runtime Node
 
-### HU 4.1 - Nginx oficial para consumidores (pendiente)
+### HU 4.1 - Observabilidad y protecciones de runtime (pendiente)
 
 #### Fases
-- F1: template.
-- F2: staging.
-- F3: guia de operacion.
+- F1: logging y metricas base.
+- F2: alarmas y limites.
+- F3: guia operativa.
 
 #### Tareas
-- `try_files`, SPA fallback, proxy a Node, cache y precompressed.
+- Estandarizar logs de serving estatico y errores.
+- Exponer metricas clave (latencia/errores/cache hits).
+- Documentar manejo de picos y rollback.
 
 #### Entregables
-- Template y guia.
+- Guia de operacion y checklist de hardening.
 
 #### Documentacion
-- `docs/deployment/` + `README.md`.
+- `docs/` + `README.md`.
 
-### HU 4.2 - Docker de referencia (pendiente)
+### HU 4.2 - Paquete de referencia para despliegue Node (pendiente)
 
 #### Fases
-- F1: Dockerfile.
-- F2: docker-compose.
-- F3: validacion server.
+- F1: templates de entorno.
+- F2: validacion en staging.
+- F3: guia final.
 
 #### Tareas
-- Definir imagenes, puertos y variables.
-- Documentar rollback.
+- Definir variables, puertos y recomendaciones de cache.
+- Incluir ejemplo de despliegue reproducible para consumidores.
 
 #### Entregables
-- Dockerfile y compose de referencia.
+- Template de despliegue y guia de puesta en marcha.
 
 #### Documentacion
-- `docs/deployment/` + `README.md`.
+- `docs/` + `README.md`.
 
 ---
 

package/bin.js

@@ -28,20 +28,4 @@ switch (args[0]) {
       console.error('Error executing gulp:', error.message);
     }
     break;
-
-  case 'dev:vite':
-    try {
-      execSync('node ./.scripts/run_vite.js dev', { stdio: 'inherit', cwd: __dirname });
-    } catch (error) {
-      console.error('Error executing Vite dev:', error.message);
-    }
-    break;
-
-  case 'build:vite':
-    try {
-      execSync('node ./.scripts/run_vite.js build', { stdio: 'inherit', cwd: __dirname });
-    } catch (error) {
-      console.error('Error executing Vite build:', error.message);
-    }
-    break;
 }

package/docs/benchmark-static.md

@@ -0,0 +1,45 @@
+# Static serving benchmark guide
+
+This benchmark measures static file serving in two reproducible scenarios:
+
+- Warm cache latency/throughput with stable keep-alive traffic.
+- Cold cache latency by forcing metadata/resolution misses on each request.
+
+## Run
+
+```bash
+npm run benchmark:static
+```
+
+## Optional tuning variables
+
+You can override defaults with environment variables:
+
+- `BENCH_PORT` (default: `3199`)
+- `BENCH_FILE_SIZE_KB` (default: `512`)
+- `BENCH_TOTAL_REQUESTS` (default: `2000`)
+- `BENCH_COLD_ITERATIONS` (default: `300`)
+
+Example:
+
+```bash
+BENCH_TOTAL_REQUESTS=4000 BENCH_COLD_ITERATIONS=600 npm run benchmark:static
+```
+
+## Output
+
+The script reports for warm and cold scenarios:
+
+- request count
+- average latency
+- `p50`, `p95`, `p99`
+- max latency
+- requests per second
+
+It also prints warm `p95` improvement vs cold.
+
+## Notes for consistent results
+
+- Close heavy apps before running benchmarks.
+- Run at least 3 times and compare medians.
+- Keep the same `BENCH_*` values before/after a performance patch.

package/framework/router.js

@@ -16,8 +16,12 @@ class Router {
 		this.defaultRoute = '';
 		this.server = server;
 		this.cwd = process.cwd();
+    this.staticBasePath = this.cwd.replace('core/framework', '');
     this.staticMetadataCache = new Map();
+    this.staticResolutionCache = new Map();
     this.staticFileWatchers = new Map();
+    this.staticMetadataMaxAgeMs = 1000;
+    this.staticStreamChunkSize = 128 * 1024;
     this.mimes = {
       'png': 'image/png',
       'webp': 'image/webp',
@@ -32,6 +36,10 @@ class Router {
       'pdf': 'application/pdf',
       'json': 'application/json'
     };
+    this.mimeHeaders = Object.keys(this.mimes).reduce((headers, ext) => {
+      headers[ext] = { 'Content-Type': this.mimes[ext] };
+      return headers;
+    }, {});
     this.compressionMimes = [ 'css', 'js' ];
     this.compressionFiles = [ 'vanilla.min.js', 'app.min.css' ];
     this.enablePrecompressedNegotiation = Boolean(server?.options?.enable_precompressed_negotiation);
@@ -102,14 +110,13 @@ class Router {
 					
 					if (obj.mimes[ext] != undefined && obj.mimes[ext] != 'undefined') {
 						extHandled = true;
-						extHeader = { 'Content-Type': obj.mimes[ext] };
+						extHeader = obj.mimeHeaders[ext];
 					}
 
 					if (extHandled) {
 
-						let rep = obj.cwd.replace('core/framework', ''), 
-							route = request.path,
-							filename = path.join(rep, route), 
+						let route = request.path,
+							filename = path.join(obj.staticBasePath, route), 
 							filePrivate = obj.isProtectedFile(route);
 
             if (filePrivate) {
@@ -118,25 +125,13 @@ class Router {
 
             let staticCandidates = obj.getStaticCandidates(request, ext, filename);
             let hasConditionalHeaders = Boolean(req.headers['if-none-match'] || req.headers['if-modified-since']);
-            obj.resolveFirstAvailableStaticFile(staticCandidates, hasConditionalHeaders, (err, staticFile) => {
+            obj.resolveFirstAvailableStaticFile(route, request.acceptEncoding, staticCandidates, hasConditionalHeaders, (err, staticFile) => {
               if (err || !staticFile) {
                 return obj.onNotFound(response);
               }
 
-              let staticHeaders = Object.assign({}, extHeader);
-              if (staticFile.contentEncoding) {
-                staticHeaders['Content-Encoding'] = staticFile.contentEncoding;
-              }
-              if (staticCandidates.some((candidate) => candidate.contentEncoding)) {
-                staticHeaders['Vary'] = 'Accept-Encoding';
-              }
-
               let metadata = staticFile.metadata;
-              staticHeaders['Content-Length'] = metadata.size;
-              staticHeaders['ETag'] = metadata.etag;
-              staticHeaders['Last-Modified'] = metadata.lastModified;
-              // Force revalidation to keep clients fresh without hard reload.
-              staticHeaders['Cache-Control'] = 'no-cache, must-revalidate';
+              let staticHeaders = obj.buildStaticHeaders(extHeader, staticCandidates, staticFile.contentEncoding, metadata);
 
               if (obj.isNotModified(req, metadata)) {
                 let notModifiedHeaders = Object.assign({}, staticHeaders);
@@ -145,8 +140,12 @@ class Router {
                 return res.end();
               }
 
-              const fileStream = fs.createReadStream(staticFile.filename);
+              const fileStream = fs.createReadStream(staticFile.filename, {
+                highWaterMark: obj.staticStreamChunkSize
+              });
               fileStream.on('error', (streamErr) => {
+                obj.staticMetadataCache.delete(staticFile.filename);
+                obj.staticResolutionCache.clear();
                 console.error("Error reading file:", streamErr);
                 res.writeHead(500);
                 res.end('Server Error');
@@ -171,6 +170,10 @@ class Router {
       return callback(null, cachedMetadata);
     }
 
+    if (cachedMetadata && forceRefresh && !obj.shouldRefreshConditionalMetadata(cachedMetadata)) {
+      return callback(null, cachedMetadata);
+    }
+
     fs.stat(filename, (err, stats) => {
       if (err || !stats.isFile()) {
         return callback(err || new Error('File not found'));
@@ -179,7 +182,8 @@ class Router {
       let metadata = {
         size: stats.size,
         lastModified: stats.mtime.toUTCString(),
-        etag: `W/"${stats.size}-${Math.floor(stats.mtimeMs)}"`
+        etag: `W/"${stats.size}-${Math.floor(stats.mtimeMs)}"`,
+        cachedAt: Date.now()
       };
 
       obj.staticMetadataCache.set(filename, metadata);
@@ -214,8 +218,24 @@ class Router {
     return compressedCandidates.concat(candidates);
   }
 
-  resolveFirstAvailableStaticFile(candidates, forceRefresh, callback) {
+  resolveFirstAvailableStaticFile(route, acceptEncoding, candidates, forceRefresh, callback) {
     let obj = this;
+    let resolutionKey = obj.getStaticResolutionKey(route, acceptEncoding);
+    let cachedResolution = obj.staticResolutionCache.get(resolutionKey);
+    if (cachedResolution) {
+      return obj.getStaticFileMetadata(cachedResolution.filename, forceRefresh, (cachedErr, cachedMetadata) => {
+        if (!cachedErr && cachedMetadata) {
+          return callback(null, {
+            filename: cachedResolution.filename,
+            contentEncoding: cachedResolution.contentEncoding,
+            metadata: cachedMetadata
+          });
+        }
+        obj.staticResolutionCache.delete(resolutionKey);
+        obj.resolveFirstAvailableStaticFile(route, acceptEncoding, candidates, forceRefresh, callback);
+      });
+    }
+
     let index = 0;
     function resolveCandidate() {
       let currentCandidate = candidates[index];
@@ -225,6 +245,10 @@ class Router {
 
       obj.getStaticFileMetadata(currentCandidate.filename, forceRefresh, (err, metadata) => {
         if (!err && metadata) {
+          obj.staticResolutionCache.set(resolutionKey, {
+            filename: currentCandidate.filename,
+            contentEncoding: currentCandidate.contentEncoding
+          });
           return callback(null, {
             filename: currentCandidate.filename,
             contentEncoding: currentCandidate.contentEncoding,
@@ -239,6 +263,35 @@ class Router {
     resolveCandidate();
   }
 
+  getStaticResolutionKey(route, acceptEncoding) {
+    let normalizedEncodings = Array.isArray(acceptEncoding) ? acceptEncoding.join(',') : '';
+    return `${route}|${normalizedEncodings}`;
+  }
+
+  shouldRefreshConditionalMetadata(metadata) {
+    if (!metadata || !metadata.cachedAt) {
+      return true;
+    }
+    return Date.now() - metadata.cachedAt > this.staticMetadataMaxAgeMs;
+  }
+
+  buildStaticHeaders(extHeader, candidates, contentEncoding, metadata) {
+    let staticHeaders = Object.assign({}, extHeader);
+    if (contentEncoding) {
+      staticHeaders['Content-Encoding'] = contentEncoding;
+    }
+    if (candidates.some((candidate) => candidate.contentEncoding)) {
+      staticHeaders['Vary'] = 'Accept-Encoding';
+    }
+
+    staticHeaders['Content-Length'] = metadata.size;
+    staticHeaders['ETag'] = metadata.etag;
+    staticHeaders['Last-Modified'] = metadata.lastModified;
+    // Force revalidation to keep clients fresh without hard reload.
+    staticHeaders['Cache-Control'] = 'no-cache, must-revalidate';
+    return staticHeaders;
+  }
+
   supportsEncoding(acceptEncoding, encoding) {
     if (!Array.isArray(acceptEncoding)) {
       return false;
@@ -279,6 +332,7 @@ class Router {
     try {
       let watcher = fs.watch(filename, (eventType) => {
         obj.staticMetadataCache.delete(filename);
+        obj.staticResolutionCache.clear();
         if (eventType === 'rename') {
           let renamedWatcher = obj.staticFileWatchers.get(filename);
           if (renamedWatcher) {
@@ -290,6 +344,7 @@ class Router {
 
       watcher.on('error', () => {
         obj.staticMetadataCache.delete(filename);
+        obj.staticResolutionCache.clear();
         let activeWatcher = obj.staticFileWatchers.get(filename);
         if (activeWatcher) {
           activeWatcher.close();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vanilla-jet",
-  "version": "1.4.0",
+  "version": "1.4.1",
   "description": "VannilaJet framework",
   "main": "index.js",
   "bin": {
@@ -9,12 +9,11 @@
   "scripts": {
     "setup": "node ./.scripts/generate_packages_json.js",
     "dev": "gulp dev --env development",
-    "dev:vite": "node ./.scripts/run_vite.js dev",
-    "build:vite": "node ./.scripts/run_vite.js build",
     "build:qa": "gulp build --env qa",
     "build:staging": "gulp build --env staging",
     "build:prod": "gulp build --env production",
-    "test": "node -e \"console.log('No automated tests configured yet')\""
+    "test": "node -e \"console.log('No automated tests configured yet')\"",
+    "benchmark:static": "node ./scripts/benchmark-static.js"
   },
   "repository": {
     "type": "git",
@@ -33,6 +32,15 @@
   "dependencies": {
     "blueimp-md5": "2.19.0",
     "chalk": "4.1.2",
+    "html-minifier-terser": "7.2.0",
+    "js-beautify": "1.15.4",
+    "jsrsasign": "11.1.0",
+    "jwt-simple": "0.5.6",
+    "minimist": "1.2.8",
+    "nodemon": "3.1.10",
+    "nunjucks": "3.2.4",
+    "underscore": ">= 1.12.x",
+    "zlib": "1.0.5",
     "del": "^6.0.0",
     "gulp": "^4.0.2",
     "gulp-clean-css": "^4.3.0",
@@ -45,16 +53,6 @@
     "gulp-rename": "^2.0.0",
     "gulp-shell": "^0.8.0",
     "gulp-uglify": "^3.0.2",
-    "gulp-watch": "^5.0.1",
-    "html-minifier-terser": "7.2.0",
-    "js-beautify": "1.15.4",
-    "jsrsasign": "11.1.0",
-    "jwt-simple": "0.5.6",
-    "minimist": "1.2.8",
-    "nodemon": "3.1.10",
-    "nunjucks": "3.2.4",
-    "underscore": ">= 1.12.x",
-    "vite": "^7.3.1",
-    "zlib": "1.0.5"
+    "gulp-watch": "^5.0.1"
   }
 }

package/scripts/benchmark-static.js

@@ -0,0 +1,201 @@
+const fs = require('fs');
+const http = require('http');
+const os = require('os');
+const path = require('path');
+const { performance } = require('perf_hooks');
+
+const Server = require('../framework/server.js');
+
+const BENCH_PORT = Number(process.env.BENCH_PORT || 3199);
+const BENCH_FILE_SIZE_KB = Number(process.env.BENCH_FILE_SIZE_KB || 512);
+const BENCH_TOTAL_REQUESTS = Number(process.env.BENCH_TOTAL_REQUESTS || 2000);
+const BENCH_COLD_ITERATIONS = Number(process.env.BENCH_COLD_ITERATIONS || 300);
+const BENCH_PATH = '/public/scripts/vanilla.min.js';
+
+function ensureDir(dirPath) {
+  fs.mkdirSync(dirPath, { recursive: true });
+}
+
+function createFixtureWorkspace(rootPath) {
+  ensureDir(path.join(rootPath, 'assets'));
+  ensureDir(path.join(rootPath, 'public', 'scripts'));
+
+  const bytes = BENCH_FILE_SIZE_KB * 1024;
+  const filePath = path.join(rootPath, BENCH_PATH);
+  const content = Buffer.alloc(bytes, 'a');
+  fs.writeFileSync(filePath, content);
+}
+
+function createServerOptions(port) {
+  return {
+    settings: {
+      profile: {
+        port: port,
+        https_server: false,
+        enable_precompressed_negotiation: true
+      },
+      shared: {},
+      security: {}
+    }
+  };
+}
+
+function percentile(values, percentileValue) {
+  if (!values.length) {
+    return 0;
+  }
+  const sorted = values.slice().sort((a, b) => a - b);
+  const index = Math.min(sorted.length - 1, Math.ceil((percentileValue / 100) * sorted.length) - 1);
+  return sorted[index];
+}
+
+function summarize(values, elapsedMs) {
+  const total = values.length;
+  const sum = values.reduce((acc, current) => acc + current, 0);
+  return {
+    count: total,
+    avgMs: total ? sum / total : 0,
+    p50Ms: percentile(values, 50),
+    p95Ms: percentile(values, 95),
+    p99Ms: percentile(values, 99),
+    maxMs: values.length ? Math.max(...values) : 0,
+    rps: elapsedMs > 0 ? (total * 1000) / elapsedMs : 0
+  };
+}
+
+function printSummary(title, summary) {
+  console.log(`\n${title}`);
+  console.log(`  requests: ${summary.count}`);
+  console.log(`  avg:      ${summary.avgMs.toFixed(2)} ms`);
+  console.log(`  p50:      ${summary.p50Ms.toFixed(2)} ms`);
+  console.log(`  p95:      ${summary.p95Ms.toFixed(2)} ms`);
+  console.log(`  p99:      ${summary.p99Ms.toFixed(2)} ms`);
+  console.log(`  max:      ${summary.maxMs.toFixed(2)} ms`);
+  console.log(`  rps:      ${summary.rps.toFixed(2)}`);
+}
+
+function requestOnce(agent, port, headers) {
+  return new Promise((resolve, reject) => {
+    const start = performance.now();
+    const req = http.request({
+      hostname: '127.0.0.1',
+      port: port,
+      path: BENCH_PATH,
+      method: 'GET',
+      headers: headers || {},
+      agent: agent
+    }, (res) => {
+      res.on('data', () => {});
+      res.on('end', () => {
+        resolve({
+          statusCode: res.statusCode,
+          durationMs: performance.now() - start
+        });
+      });
+    });
+    req.on('error', reject);
+    req.end();
+  });
+}
+
+function waitForServerListening(instance) {
+  if (instance && instance.httpx && instance.httpx.listening) {
+    return Promise.resolve();
+  }
+  return new Promise((resolve) => {
+    instance.httpx.once('listening', resolve);
+  });
+}
+
+async function runWarmBenchmark(port) {
+  const agent = new http.Agent({
+    keepAlive: true,
+    maxSockets: 1
+  });
+  const latencies = [];
+  const startedAt = performance.now();
+  for (let index = 0; index < BENCH_TOTAL_REQUESTS; index += 1) {
+    const result = await requestOnce(agent, port, {
+      'accept-encoding': 'br, gzip'
+    });
+    if (result.statusCode !== 200) {
+      throw new Error(`Unexpected status ${result.statusCode} in warm benchmark`);
+    }
+    latencies.push(result.durationMs);
+  }
+  agent.destroy();
+  return summarize(latencies, performance.now() - startedAt);
+}
+
+async function runColdBenchmark(server, port) {
+  const latencies = [];
+  const agent = new http.Agent({
+    keepAlive: true,
+    maxSockets: 1
+  });
+  const startedAt = performance.now();
+  for (let index = 0; index < BENCH_COLD_ITERATIONS; index += 1) {
+    server.router.staticMetadataCache.clear();
+    server.router.staticResolutionCache.clear();
+
+    const sample = await requestOnce(agent, port, {
+      'accept-encoding': 'br, gzip'
+    });
+    if (sample.statusCode !== 200) {
+      throw new Error(`Unexpected status ${sample.statusCode} in cold benchmark`);
+    }
+    latencies.push(sample.durationMs);
+  }
+  agent.destroy();
+  return summarize(latencies, performance.now() - startedAt);
+}
+
+async function main() {
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'vanillajet-bench-'));
+  createFixtureWorkspace(tmpDir);
+  const previousCwd = process.cwd();
+  process.chdir(tmpDir);
+
+  const server = new Server(createServerOptions(BENCH_PORT), []);
+  await waitForServerListening(server);
+  try {
+    const warmup = await requestOnce(undefined, BENCH_PORT, {});
+    if (warmup.statusCode !== 200) {
+      throw new Error(`Warmup request failed with status ${warmup.statusCode}`);
+    }
+
+    const coldResult = await runColdBenchmark(server, BENCH_PORT);
+    printSummary('Cold cache benchmark', coldResult);
+
+    const warmResult = await runWarmBenchmark(BENCH_PORT);
+    printSummary('Warm cache benchmark', warmResult);
+
+    await new Promise((resolve) => {
+      server.httpx.close(() => {
+        resolve();
+      });
+    });
+    process.chdir(previousCwd);
+
+    const p95Improvement = coldResult.p95Ms > 0
+      ? ((coldResult.p95Ms - warmResult.p95Ms) / coldResult.p95Ms) * 100
+      : 0;
+    console.log(`\nWarm p95 improvement vs cold: ${p95Improvement.toFixed(2)}%`);
+  } catch (error) {
+    await new Promise((resolve) => {
+      server.httpx.close(() => {
+        resolve();
+      });
+    }).catch(() => {});
+    process.chdir(previousCwd);
+    throw error;
+  } finally {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  }
+}
+
+main().catch((error) => {
+  console.error('\nStatic benchmark failed');
+  console.error(error);
+  process.exit(1);
+});

package/.scripts/run_vite.js

@@ -1,36 +0,0 @@
-const path = require('path');
-const { spawnSync } = require('child_process');
-
-function resolveConsumerRoot() {
-  return process.cwd()
-    .replace('/node_modules/vanilla-jet', '')
-    .replace('/.scripts', '')
-    .replace('/.grunt', '');
-}
-
-function main() {
-  const action = process.argv[2] || 'dev';
-  const viteCommand = action === 'build' ? 'build' : 'serve';
-  const packageRoot = path.resolve(__dirname, '..');
-  const consumerRoot = resolveConsumerRoot();
-  const vitePackageJson = require.resolve('vite/package.json', { paths: [packageRoot] });
-  const viteBin = path.join(path.dirname(vitePackageJson), 'bin/vite.js');
-  const configFile = path.join(packageRoot, 'vite.config.js');
-
-  const args = [viteBin, viteCommand, '--config', configFile];
-  if (viteCommand === 'serve') {
-    args.push('--host');
-  }
-
-  const result = spawnSync(process.execPath, args, {
-    stdio: 'inherit',
-    cwd: consumerRoot,
-    env: Object.assign({}, process.env, {
-      VANILLAJET_PACKAGE_ROOT: packageRoot
-    })
-  });
-
-  process.exit(typeof result.status === 'number' ? result.status : 1);
-}
-
-main();

package/vite.config.js

@@ -1,184 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-const { defineConfig } = require('vite');
-
-function resolveConsumerRoot() {
-  return process.cwd()
-    .replace('/node_modules/vanilla-jet', '')
-    .replace('/.scripts', '')
-    .replace('/.grunt', '');
-}
-
-function collectScriptFiles(dirPath) {
-  if (!fs.existsSync(dirPath)) {
-    return [];
-  }
-
-  const files = [];
-  const entries = fs.readdirSync(dirPath, { withFileTypes: true });
-  entries.forEach((entry) => {
-    const entryPath = path.join(dirPath, entry.name);
-    if (entry.isDirectory()) {
-      files.push(...collectScriptFiles(entryPath));
-      return;
-    }
-
-    if (entry.isFile() && entry.name.endsWith('.js')) {
-      files.push(entryPath);
-    }
-  });
-  return files;
-}
-
-function normalize(filePath) {
-  return filePath.split(path.sep).join('/');
-}
-
-function scriptPriority(filePath) {
-  const normalized = normalize(filePath);
-  if (normalized.includes('/assets/scripts/controllers/')) return 0;
-  if (normalized.includes('/assets/scripts/views/')) return 1;
-  if (normalized.includes('/assets/scripts/api/')) return 2;
-  return 3;
-}
-
-function includeInBundle(filePath) {
-  const normalized = normalize(filePath);
-  if (normalized.includes('/assets/scripts/core/')) return false;
-  if (normalized.includes('/assets/scripts/plugins/')) return false;
-  return true;
-}
-
-function writeVirtualEntry(virtualEntryPath, orderedScripts, lessEntryPath, hasLess) {
-  const imports = orderedScripts.map((scriptPath, index) => {
-    const importPath = normalize(scriptPath) + '?raw';
-    return `import __vanillajet_script_${index} from ${JSON.stringify(importPath)};`;
-  });
-
-  if (hasLess) {
-    imports.push(`import ${JSON.stringify(normalize(lessEntryPath))};`);
-  }
-
-  const mappings = orderedScripts.map((scriptPath, index) => {
-    const rel = normalize(path.relative(path.dirname(virtualEntryPath), scriptPath));
-    return `{ source: __vanillajet_script_${index}, file: ${JSON.stringify(rel)} }`;
-  });
-
-  const lines = [
-    '/* Auto-generated by VanillaJet Vite config. */',
-    ...imports,
-    '',
-    'function executeGlobalScript(sourceCode, sourceFile) {',
-    '  const tag = document.createElement("script");',
-    '  tag.type = "text/javascript";',
-    '  tag.setAttribute("data-vanillajet-source", sourceFile);',
-    '  tag.text = sourceCode;',
-    '  document.head.appendChild(tag);',
-    '  document.head.removeChild(tag);',
-    '}',
-    '',
-    `const scriptMap = [${mappings.join(', ')}];`,
-    'scriptMap.forEach(({ source, file }) => executeGlobalScript(source, file));',
-    '',
-    'if (import.meta.hot) {',
-    '  import.meta.hot.accept(() => {',
-    '    window.location.reload();',
-    '  });',
-    '}'
-  ];
-
-  fs.mkdirSync(path.dirname(virtualEntryPath), { recursive: true });
-  fs.writeFileSync(virtualEntryPath, lines.join('\n'), 'utf8');
-}
-
-module.exports = defineConfig(({ command, mode }) => {
-  const rootDir = resolveConsumerRoot();
-  const scriptsDir = path.join(rootDir, 'assets/scripts');
-  const lessEntryPath = path.join(rootDir, 'assets/styles/less/admin.less');
-  const virtualEntryPath = path.join(rootDir, '.vanillajet/vite-entry.js');
-
-  const scripts = collectScriptFiles(scriptsDir)
-    .filter(includeInBundle)
-    .sort((left, right) => {
-      const priorityDiff = scriptPriority(left) - scriptPriority(right);
-      if (priorityDiff !== 0) {
-        return priorityDiff;
-      }
-      return normalize(left).localeCompare(normalize(right));
-    });
-  const hasLess = fs.existsSync(lessEntryPath);
-  const hasSources = scripts.length > 0 || hasLess;
-
-  writeVirtualEntry(virtualEntryPath, scripts, lessEntryPath, hasLess);
-
-  const helperPath = '/__vanillajet__/';
-  const helperHtml = [
-    '<!doctype html>',
-    '<html lang="en">',
-    '<head>',
-    '  <meta charset="utf-8" />',
-    '  <meta name="viewport" content="width=device-width, initial-scale=1" />',
-    '  <title>VanillaJet Vite Dev</title>',
-    '</head>',
-    '<body>',
-    '  <h3>VanillaJet Vite dev helper</h3>',
-    '  <p>This page only loads JS/LESS from assets for DX.</p>',
-    '  <p>Nunjucks templates and legacy Node routes remain unchanged.</p>',
-    `  <script type="module" src="${normalize(path.relative(rootDir, virtualEntryPath)).startsWith('.') ? '/' + normalize(path.relative(rootDir, virtualEntryPath)).replace(/^\.\//, '') : '/' + normalize(path.relative(rootDir, virtualEntryPath))}"></script>`,
-    '</body>',
-    '</html>'
-  ].join('\n');
-
-  return {
-    root: rootDir,
-    publicDir: false,
-    server: {
-      host: true,
-      port: 5173
-    },
-    build: {
-      outDir: path.join(rootDir, 'public'),
-      emptyOutDir: false,
-      sourcemap: mode !== 'production',
-      rollupOptions: {
-        input: virtualEntryPath,
-        output: {
-          entryFileNames: 'scripts/vanilla.min.js',
-          chunkFileNames: 'scripts/chunks/[name]-[hash].js',
-          assetFileNames: (assetInfo) => {
-            if (assetInfo.name && assetInfo.name.endsWith('.css')) {
-              return 'styles/app.min.css';
-            }
-            return 'assets/[name]-[hash][extname]';
-          }
-        }
-      }
-    },
-    plugins: [
-      {
-        name: 'vanillajet-dev-helper',
-        configureServer(server) {
-          if (!hasSources) {
-            server.config.logger.warn(
-              '[vanillajet] No JS/LESS sources found under assets/. Vite will run with an empty entry.'
-            );
-          }
-
-          server.middlewares.use((req, res, next) => {
-            if (req.url === helperPath) {
-              res.setHeader('Content-Type', 'text/html; charset=utf-8');
-              res.end(helperHtml);
-              return;
-            }
-            next();
-          });
-        },
-        buildStart() {
-          if (command === 'build' && !hasSources) {
-            this.warn('[vanillajet] No JS/LESS sources found under assets/. Build will output an empty JS bundle.');
-          }
-        }
-      }
-    ]
-  };
-});