@unsetsoft/ryunix-presets 1.0.24 → 1.0.25

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@unsetsoft/ryunix-presets",
   "description": "Package with presets for different development environments.",
-  "version": "1.0.24",
+  "version": "1.0.25",
   "author": "Neyunse",
   "type": "module",
   "repository": "https://github.com/UnSetSoft/Ryunixjs",

package/webpack/bin/dev.server.mjs

@@ -49,7 +49,8 @@ const StartServer = async (cliSettings) => {
     `${defaultSettings.webpack.output.buildDirectory}/cache`,
   )
 
-  const mode = cliSettings.production || defaultSettings.webpack.production ? true : false
+  const mode =
+    cliSettings.production || defaultSettings.webpack.production ? true : false
 
   if (!mode) {
     cleanCacheDir(cacheDir)

package/webpack/bin/index.mjs

@@ -18,7 +18,7 @@ import fs from 'fs'
 import { fileURLToPath } from 'url'
 import { dirname, join } from 'path'
 import server from './prod.server.mjs'
-import config from '../utils/config.cjs';
+import config from '../utils/config.cjs'
 const __filename = fileURLToPath(import.meta.url)
 
 const __dirname = dirname(__filename)
@@ -60,7 +60,9 @@ const dev = {
   describe: 'Run server for developer mode.',
   handler: async (arg) => {
     if (defaultSettings.webpack.production) {
-      logger.error("You need use development mode! change webpack.production to false in ryunix.config.js.")
+      logger.error(
+        'You need use development mode! change webpack.production to false in ryunix.config.js.',
+      )
       return
     }
     const open = Boolean(arg.browser) || false
@@ -77,19 +79,25 @@ const prod = {
   describe: 'Run server for production mode. Requiere .ryunix/static',
   handler: async (arg) => {
     if (!defaultSettings.webpack.production) {
-      logger.error("You need use production mode!")
+      logger.error('You need use production mode!')
       return
     }
 
-    if (!fs.existsSync(join(process.cwd(), config.webpack.output.buildDirectory, 'static'))) {
-      logger.error("You need build first!")
+    if (
+      !fs.existsSync(
+        join(process.cwd(), config.webpack.output.buildDirectory, 'static'),
+      )
+    ) {
+      logger.error('You need build first!')
       return
     }
 
     server.listen(config.webpack.devServer.port, () => {
-      console.log(`Server running at http://localhost:${config.webpack.devServer.port}/`);
-    });
-  }
+      console.log(
+        `Server running at http://localhost:${config.webpack.devServer.port}/`,
+      )
+    })
+  },
 }
 
 const build = {
@@ -130,8 +138,6 @@ const build = {
         minutes > 0 ? `${minutes}m ${seconds}s` : `${seconds}s`
 
       if (defaultSettings.webpack.production) {
-
-
         await Prerender(defaultSettings.webpack.output.buildDirectory)
       }
 
@@ -153,15 +159,26 @@ const extractHTML = {
   handler: async (arg) => {
     const runPath = process.cwd()
 
-    fs.copyFile(join(__dirname, "..", "template/index.html"), join(runPath, "public/index.html"), (err) => {
-      if (err) {
-        console.error("Error extracting HTML: ", err.message);
-        return;
-      }
-      console.log("File extracted successfully. Now you can enable the template with static.customTemplate inside ryunix.config.js");
-    });
+    fs.copyFile(
+      join(__dirname, '..', 'template/index.html'),
+      join(runPath, 'public/index.html'),
+      (err) => {
+        if (err) {
+          console.error('Error extracting HTML: ', err.message)
+          return
+        }
+        console.log(
+          'File extracted successfully. Now you can enable the template with static.customTemplate inside ryunix.config.js',
+        )
+      },
+    )
   },
 }
 
-
-yargs(hideBin(process.argv)).command(dev).command(build).command(prod).command(lint).command(extractHTML).parse()
+yargs(hideBin(process.argv))
+  .command(dev)
+  .command(build)
+  .command(prod)
+  .command(lint)
+  .command(extractHTML)
+  .parse()

package/webpack/bin/prerender.mjs

@@ -29,10 +29,10 @@ const Prerender = async (directory) => {
 
   const metaExist = routes.some((route) => route.meta)
   if (metaExist && defaultSettings.static.seo.meta.length > 0) {
-
-    console.error("[Ryunix Error] You are mixing static and dynamic meta tags; you can only use one of the two. Remove static.seo.meta from ryunix.config.js.")
+    console.error(
+      '[Ryunix Error] You are mixing static and dynamic meta tags; you can only use one of the two. Remove static.seo.meta from ryunix.config.js.',
+    )
     process.exit(1)
-
   }
 
   if (routes.length === 0) {

package/webpack/bin/prod.server.mjs

@@ -1,393 +1,401 @@
-import http from 'http'
-import { promises as fs } from 'fs'
-import path from 'path'
-import { createHash } from 'crypto'
-import zlib from 'zlib'
-import { promisify } from 'util'
-import { createReadStream } from 'fs'
-import { pipeline } from 'stream/promises'
-import config from '../utils/config.cjs'
-
-const gzip = promisify(zlib.gzip)
-const brotliCompress = promisify(zlib.brotliCompress)
-
-// MIME types dictionary
-const MIME_TYPES = {
-  '.js': 'application/javascript',
-  '.mjs': 'application/javascript',
-  '.css': 'text/css',
-  '.html': 'text/html',
-  '.json': 'application/json',
-  '.png': 'image/png',
-  '.jpg': 'image/jpeg',
-  '.jpeg': 'image/jpeg',
-  '.gif': 'image/gif',
-  '.svg': 'image/svg+xml',
-  '.woff': 'font/woff',
-  '.woff2': 'font/woff2',
-  '.ttf': 'font/ttf',
-  '.eot': 'application/vnd.ms-fontobject',
-  '.otf': 'font/otf',
-  '.wasm': 'application/wasm',
-  '.ico': 'image/x-icon',
-  '.mp3': 'audio/mpeg',
-  '.mp4': 'video/mp4',
-  '.pdf': 'application/pdf',
-  '.zip': 'application/zip',
-  '.gz': 'application/gzip',
-  '.tar': 'application/x-tar',
-  '.7z': 'application/x-7z-compressed',
-  '.rar': 'application/x-rar-compressed',
-  '.avi': 'video/x-msvideo',
-  '.mov': 'video/quicktime',
-  '.wmv': 'video/x-ms-wmv',
-  '.flv': 'video/x-flv',
-  '.webm': 'video/webm',
-  '.ogg': 'audio/ogg',
-  '.ogv': 'video/ogg',
-  '.m4v': 'video/mp4',
-  '.3gp': 'video/3gpp',
-  '.3g2': 'video/3gpp2',
-  '.mkv': 'video/x-matroska',
-  '.ts': 'video/mp2t',
-}
-
-// File cache for production server
-const fileCache = new Map()
-const MAX_CACHE_SIZE = 50 * 1024 * 1024 // 50MB
-let currentCacheSize = 0
-
-/**
- * Get MIME type from file extension
- */
-const getMimeType = (filePath) => {
-  const ext = path.extname(filePath).toLowerCase()
-  return MIME_TYPES[ext] || 'application/octet-stream'
-}
-
-/**
- * Validate path to prevent directory traversal attacks
- */
-const validatePath = (requestPath, rootDir) => {
-  try {
-    const normalizedPath = path.normalize(requestPath)
-    const resolvedPath = path.resolve(rootDir, normalizedPath.slice(1))
-
-    if (!resolvedPath.startsWith(rootDir)) {
-      return null
-    }
-
-    return resolvedPath
-  } catch {
-    return null
-  }
-}
-
-/**
- * Generate ETag from file content
- */
-const generateETag = (content) => {
-  return createHash('md5').update(content).digest('hex')
-}
-
-/**
- * Check compression support (Brotli preferred over Gzip)
- */
-const getAcceptedEncoding = (headers) => {
-  const encoding = headers['accept-encoding'] || ''
-  if (encoding.includes('br')) return 'br'
-  if (encoding.includes('gzip')) return 'gzip'
-  return null
-}
-
-/**
- * Check if MIME type is compressible
- */
-const isCompressible = (mimeType) => {
-  return mimeType.startsWith('text/') ||
-    mimeType.includes('javascript') ||
-    mimeType.includes('json') ||
-    mimeType.includes('css')
-}
-
-/**
- * Parse Range header
- */
-const parseRange = (rangeHeader, fileSize) => {
-  if (!rangeHeader) return null
-
-  const parts = rangeHeader.replace(/bytes=/, '').split('-')
-  const start = parseInt(parts[0], 10)
-  const end = parts[1] ? parseInt(parts[1], 10) : fileSize - 1
-
-  if (isNaN(start) || isNaN(end) || start > end || end >= fileSize) {
-    return null
-  }
-
-  return { start, end, length: end - start + 1 }
-}
-
-/**
- * Check if file should support range requests (media files)
- */
-const supportsRangeRequests = (mimeType) => {
-  return mimeType.startsWith('video/') ||
-    mimeType.startsWith('audio/') ||
-    mimeType === 'application/pdf'
-}
-
-/**
- * Serve file with range support (for video/audio)
- */
-const serveWithRange = async (filePath, req, res, stats) => {
-  const mimeType = getMimeType(filePath)
-  const range = parseRange(req.headers.range, stats.size)
-
-  const headers = {
-    'Content-Type': mimeType,
-    'Accept-Ranges': 'bytes',
-    'Cache-Control': 'public, max-age=31536000',
-  }
-
-  if (range) {
-    // Partial content
-    headers['Content-Range'] = `bytes ${range.start}-${range.end}/${stats.size}`
-    headers['Content-Length'] = range.length
-
-    res.writeHead(206, headers)
-
-    const stream = createReadStream(filePath, { start: range.start, end: range.end })
-    await pipeline(stream, res)
-  } else {
-    // Full content
-    headers['Content-Length'] = stats.size
-    res.writeHead(200, headers)
-
-    const stream = createReadStream(filePath)
-    await pipeline(stream, res)
-  }
-
-  return true
-}
-
-/**
- * Serve static file with caching and compression
- */
-const serveStaticFile = async (filePath, req, res) => {
-  try {
-    let stats = await fs.stat(filePath)
-
-    // 👉 If is a directory
-    if (stats.isDirectory()) {
-      const indexPath = path.join(filePath, 'index.html')
-      await fs.access(indexPath)
-      stats = await fs.stat(indexPath)
-      filePath = indexPath
-    }
-
-    const mimeType = getMimeType(filePath)
-
-    // Use range requests for media files or large files
-    if (supportsRangeRequests(mimeType) || stats.size > 5 * 1024 * 1024) {
-      return await serveWithRange(filePath, req, res, stats)
-    }
-
-    let cached = fileCache.get(filePath)
-
-    if (!cached) {
-      // Read and cache file
-      const content = await fs.readFile(filePath)
-      const etag = generateETag(content)
-
-      // Compress if text-based content
-      let brotli = null
-      let gzipped = null
-
-      if (isCompressible(mimeType)) {
-        try {
-          [brotli, gzipped] = await Promise.all([
-            brotliCompress(content, {
-              params: {
-                [zlib.constants.BROTLI_PARAM_QUALITY]: 6,
-              },
-            }),
-            gzip(content),
-          ])
-        } catch {
-          // Compression failed, serve uncompressed
-        }
-      }
-
-      cached = {
-        content,
-        brotli,
-        gzipped,
-        etag,
-        mimeType,
-        size: stats.size,
-      }
-
-      // Update cache
-      if (currentCacheSize + stats.size < MAX_CACHE_SIZE) {
-        fileCache.set(filePath, cached)
-        currentCacheSize += stats.size
-      }
-    }
-
-    // Check ETag for 304 Not Modified
-    if (req.headers['if-none-match'] === cached.etag) {
-      res.writeHead(304)
-      res.end()
-      return true
-    }
-
-    // Select best encoding
-    const encoding = getAcceptedEncoding(req.headers)
-    let responseContent = cached.content
-    let contentEncoding = null
-
-    if (encoding === 'br' && cached.brotli) {
-      responseContent = cached.brotli
-      contentEncoding = 'br'
-    } else if (encoding === 'gzip' && cached.gzipped) {
-      responseContent = cached.gzipped
-      contentEncoding = 'gzip'
-    }
-
-    const headers = {
-      'Content-Type': cached.mimeType,
-      'Content-Length': responseContent.length,
-      'ETag': cached.etag,
-      'Cache-Control': 'public, max-age=31536000',
-    }
-
-    if (contentEncoding) {
-      headers['Content-Encoding'] = contentEncoding
-    }
-
-    res.writeHead(200, headers)
-    res.end(responseContent)
-    return true
-
-  } catch (error) {
-    return false
-  }
-}
-
-/**
- * Serve HTML page with SPA fallback support
- */
-const serveHTMLPage = async (pathname, staticDir, req, res) => {
-  try {
-    const candidates = []
-
-    // / → /index.html
-    if (pathname === '/') {
-      candidates.push(path.join(staticDir, 'index.html'))
-    } else {
-      // /test → /test/index.html
-      candidates.push(path.join(staticDir, pathname, 'index.html'))
-
-      // /test → /test.html
-      candidates.push(path.join(staticDir, `${pathname}.html`))
-
-      // SPA fallback
-      candidates.push(path.join(staticDir, 'index.html'))
-    }
-
-    let pageFile = null
-
-    for (const file of candidates) {
-      try {
-        await fs.access(file)
-        pageFile = file
-        break
-      } catch { }
-    }
-
-    if (!pageFile) {
-      res.writeHead(404, { 'Content-Type': 'text/html; charset=utf-8' })
-      res.end('404')
-      return
-    }
-
-    const content = await fs.readFile(pageFile, 'utf-8')
-    const etag = generateETag(Buffer.from(content))
-
-    if (req.headers['if-none-match'] === etag) {
-      res.writeHead(304)
-      res.end()
-      return
-    }
-
-    // Compress HTML
-    let responseContent = content
-    const headers = {
-      'Content-Type': 'text/html; charset=utf-8',
-      'ETag': etag,
-      'Cache-Control': 'no-cache',
-    }
-
-    const encoding = getAcceptedEncoding(req.headers)
-
-    if (encoding === 'br') {
-      try {
-        responseContent = await brotliCompress(Buffer.from(content))
-        headers['Content-Encoding'] = 'br'
-      } catch {
-        // Fallback to uncompressed
-      }
-    } else if (encoding === 'gzip') {
-      try {
-        responseContent = await gzip(Buffer.from(content))
-        headers['Content-Encoding'] = 'gzip'
-      } catch {
-        // Fallback to uncompressed
-      }
-    }
-
-    headers['Content-Length'] = Buffer.byteLength(responseContent)
-
-    res.writeHead(200, headers)
-    res.end(responseContent)
-
-  } catch (error) {
-    res.writeHead(500, { 'Content-Type': 'text/html; charset=utf-8' })
-    res.end('500')
-  }
-}
-
-/**
- * Request handler
- */
-const requestHandler = async (req, res) => {
-  const rootDir = process.cwd()
-  const staticDir = path.join(rootDir, config.webpack.output.buildDirectory, 'static')
-
-  try {
-    const parsedUrl = new URL(req.url, `http://${req.headers.host}`)
-    const pathname = decodeURIComponent(parsedUrl.pathname)
-
-    const safePath = validatePath(pathname, staticDir)
-    if (!safePath) {
-      res.writeHead(403, { 'Content-Type': 'text/plain; charset=utf-8' })
-      res.end('403')
-      return
-    }
-
-    const fileServed = await serveStaticFile(safePath, req, res)
-
-    if (!fileServed) {
-      await serveHTMLPage(pathname, staticDir, req, res)
-    }
-
-  } catch (error) {
-    console.error('[Ryunix Server Error]:', error.message)
-    res.writeHead(500, { 'Content-Type': 'text/plain; charset=utf-8' })
-    res.end('500')
-  }
-}
-
-const httpServ = http.createServer(requestHandler)
-
-export default httpServ
+import http from 'http'
+import { promises as fs } from 'fs'
+import path from 'path'
+import { createHash } from 'crypto'
+import zlib from 'zlib'
+import { promisify } from 'util'
+import { createReadStream } from 'fs'
+import { pipeline } from 'stream/promises'
+import config from '../utils/config.cjs'
+
+const gzip = promisify(zlib.gzip)
+const brotliCompress = promisify(zlib.brotliCompress)
+
+// MIME types dictionary
+const MIME_TYPES = {
+  '.js': 'application/javascript',
+  '.mjs': 'application/javascript',
+  '.css': 'text/css',
+  '.html': 'text/html',
+  '.json': 'application/json',
+  '.png': 'image/png',
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.gif': 'image/gif',
+  '.svg': 'image/svg+xml',
+  '.woff': 'font/woff',
+  '.woff2': 'font/woff2',
+  '.ttf': 'font/ttf',
+  '.eot': 'application/vnd.ms-fontobject',
+  '.otf': 'font/otf',
+  '.wasm': 'application/wasm',
+  '.ico': 'image/x-icon',
+  '.mp3': 'audio/mpeg',
+  '.mp4': 'video/mp4',
+  '.pdf': 'application/pdf',
+  '.zip': 'application/zip',
+  '.gz': 'application/gzip',
+  '.tar': 'application/x-tar',
+  '.7z': 'application/x-7z-compressed',
+  '.rar': 'application/x-rar-compressed',
+  '.avi': 'video/x-msvideo',
+  '.mov': 'video/quicktime',
+  '.wmv': 'video/x-ms-wmv',
+  '.flv': 'video/x-flv',
+  '.webm': 'video/webm',
+  '.ogg': 'audio/ogg',
+  '.ogv': 'video/ogg',
+  '.m4v': 'video/mp4',
+  '.3gp': 'video/3gpp',
+  '.3g2': 'video/3gpp2',
+  '.mkv': 'video/x-matroska',
+  '.ts': 'video/mp2t',
+}
+
+// File cache for production server
+const fileCache = new Map()
+const MAX_CACHE_SIZE = 50 * 1024 * 1024 // 50MB
+let currentCacheSize = 0
+
+/**
+ * Get MIME type from file extension
+ */
+const getMimeType = (filePath) => {
+  const ext = path.extname(filePath).toLowerCase()
+  return MIME_TYPES[ext] || 'application/octet-stream'
+}
+
+/**
+ * Validate path to prevent directory traversal attacks
+ */
+const validatePath = (requestPath, rootDir) => {
+  try {
+    const normalizedPath = path.normalize(requestPath)
+    const resolvedPath = path.resolve(rootDir, normalizedPath.slice(1))
+
+    if (!resolvedPath.startsWith(rootDir)) {
+      return null
+    }
+
+    return resolvedPath
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Generate ETag from file content
+ */
+const generateETag = (content) => {
+  return createHash('md5').update(content).digest('hex')
+}
+
+/**
+ * Check compression support (Brotli preferred over Gzip)
+ */
+const getAcceptedEncoding = (headers) => {
+  const encoding = headers['accept-encoding'] || ''
+  if (encoding.includes('br')) return 'br'
+  if (encoding.includes('gzip')) return 'gzip'
+  return null
+}
+
+/**
+ * Check if MIME type is compressible
+ */
+const isCompressible = (mimeType) => {
+  return (
+    mimeType.startsWith('text/') ||
+    mimeType.includes('javascript') ||
+    mimeType.includes('json') ||
+    mimeType.includes('css')
+  )
+}
+
+/**
+ * Parse Range header
+ */
+const parseRange = (rangeHeader, fileSize) => {
+  if (!rangeHeader) return null
+
+  const parts = rangeHeader.replace(/bytes=/, '').split('-')
+  const start = parseInt(parts[0], 10)
+  const end = parts[1] ? parseInt(parts[1], 10) : fileSize - 1
+
+  if (isNaN(start) || isNaN(end) || start > end || end >= fileSize) {
+    return null
+  }
+
+  return { start, end, length: end - start + 1 }
+}
+
+/**
+ * Check if file should support range requests (media files)
+ */
+const supportsRangeRequests = (mimeType) => {
+  return (
+    mimeType.startsWith('video/') ||
+    mimeType.startsWith('audio/') ||
+    mimeType === 'application/pdf'
+  )
+}
+
+/**
+ * Serve file with range support (for video/audio)
+ */
+const serveWithRange = async (filePath, req, res, stats) => {
+  const mimeType = getMimeType(filePath)
+  const range = parseRange(req.headers.range, stats.size)
+
+  const headers = {
+    'Content-Type': mimeType,
+    'Accept-Ranges': 'bytes',
+    'Cache-Control': 'public, max-age=31536000',
+  }
+
+  if (range) {
+    // Partial content
+    headers['Content-Range'] = `bytes ${range.start}-${range.end}/${stats.size}`
+    headers['Content-Length'] = range.length
+
+    res.writeHead(206, headers)
+
+    const stream = createReadStream(filePath, {
+      start: range.start,
+      end: range.end,
+    })
+    await pipeline(stream, res)
+  } else {
+    // Full content
+    headers['Content-Length'] = stats.size
+    res.writeHead(200, headers)
+
+    const stream = createReadStream(filePath)
+    await pipeline(stream, res)
+  }
+
+  return true
+}
+
+/**
+ * Serve static file with caching and compression
+ */
+const serveStaticFile = async (filePath, req, res) => {
+  try {
+    let stats = await fs.stat(filePath)
+
+    // 👉 If is a directory
+    if (stats.isDirectory()) {
+      const indexPath = path.join(filePath, 'index.html')
+      await fs.access(indexPath)
+      stats = await fs.stat(indexPath)
+      filePath = indexPath
+    }
+
+    const mimeType = getMimeType(filePath)
+
+    // Use range requests for media files or large files
+    if (supportsRangeRequests(mimeType) || stats.size > 5 * 1024 * 1024) {
+      return await serveWithRange(filePath, req, res, stats)
+    }
+
+    let cached = fileCache.get(filePath)
+
+    if (!cached) {
+      // Read and cache file
+      const content = await fs.readFile(filePath)
+      const etag = generateETag(content)
+
+      // Compress if text-based content
+      let brotli = null
+      let gzipped = null
+
+      if (isCompressible(mimeType)) {
+        try {
+          ;[brotli, gzipped] = await Promise.all([
+            brotliCompress(content, {
+              params: {
+                [zlib.constants.BROTLI_PARAM_QUALITY]: 6,
+              },
+            }),
+            gzip(content),
+          ])
+        } catch {
+          // Compression failed, serve uncompressed
+        }
+      }
+
+      cached = {
+        content,
+        brotli,
+        gzipped,
+        etag,
+        mimeType,
+        size: stats.size,
+      }
+
+      // Update cache
+      if (currentCacheSize + stats.size < MAX_CACHE_SIZE) {
+        fileCache.set(filePath, cached)
+        currentCacheSize += stats.size
+      }
+    }
+
+    // Check ETag for 304 Not Modified
+    if (req.headers['if-none-match'] === cached.etag) {
+      res.writeHead(304)
+      res.end()
+      return true
+    }
+
+    // Select best encoding
+    const encoding = getAcceptedEncoding(req.headers)
+    let responseContent = cached.content
+    let contentEncoding = null
+
+    if (encoding === 'br' && cached.brotli) {
+      responseContent = cached.brotli
+      contentEncoding = 'br'
+    } else if (encoding === 'gzip' && cached.gzipped) {
+      responseContent = cached.gzipped
+      contentEncoding = 'gzip'
+    }
+
+    const headers = {
+      'Content-Type': cached.mimeType,
+      'Content-Length': responseContent.length,
+      ETag: cached.etag,
+      'Cache-Control': 'public, max-age=31536000',
+    }
+
+    if (contentEncoding) {
+      headers['Content-Encoding'] = contentEncoding
+    }
+
+    res.writeHead(200, headers)
+    res.end(responseContent)
+    return true
+  } catch (error) {
+    return false
+  }
+}
+
+/**
+ * Serve HTML page with SPA fallback support
+ */
+const serveHTMLPage = async (pathname, staticDir, req, res) => {
+  try {
+    const candidates = []
+
+    // / → /index.html
+    if (pathname === '/') {
+      candidates.push(path.join(staticDir, 'index.html'))
+    } else {
+      // /test → /test/index.html
+      candidates.push(path.join(staticDir, pathname, 'index.html'))
+
+      // /test → /test.html
+      candidates.push(path.join(staticDir, `${pathname}.html`))
+
+      // SPA fallback
+      candidates.push(path.join(staticDir, 'index.html'))
+    }
+
+    let pageFile = null
+
+    for (const file of candidates) {
+      try {
+        await fs.access(file)
+        pageFile = file
+        break
+      } catch {}
+    }
+
+    if (!pageFile) {
+      res.writeHead(404, { 'Content-Type': 'text/html; charset=utf-8' })
+      res.end('404')
+      return
+    }
+
+    const content = await fs.readFile(pageFile, 'utf-8')
+    const etag = generateETag(Buffer.from(content))
+
+    if (req.headers['if-none-match'] === etag) {
+      res.writeHead(304)
+      res.end()
+      return
+    }
+
+    // Compress HTML
+    let responseContent = content
+    const headers = {
+      'Content-Type': 'text/html; charset=utf-8',
+      ETag: etag,
+      'Cache-Control': 'no-cache',
+    }
+
+    const encoding = getAcceptedEncoding(req.headers)
+
+    if (encoding === 'br') {
+      try {
+        responseContent = await brotliCompress(Buffer.from(content))
+        headers['Content-Encoding'] = 'br'
+      } catch {
+        // Fallback to uncompressed
+      }
+    } else if (encoding === 'gzip') {
+      try {
+        responseContent = await gzip(Buffer.from(content))
+        headers['Content-Encoding'] = 'gzip'
+      } catch {
+        // Fallback to uncompressed
+      }
+    }
+
+    headers['Content-Length'] = Buffer.byteLength(responseContent)
+
+    res.writeHead(200, headers)
+    res.end(responseContent)
+  } catch (error) {
+    res.writeHead(500, { 'Content-Type': 'text/html; charset=utf-8' })
+    res.end('500')
+  }
+}
+
+/**
+ * Request handler
+ */
+const requestHandler = async (req, res) => {
+  const rootDir = process.cwd()
+  const staticDir = path.join(
+    rootDir,
+    config.webpack.output.buildDirectory,
+    'static',
+  )
+
+  try {
+    const parsedUrl = new URL(req.url, `http://${req.headers.host}`)
+    const pathname = decodeURIComponent(parsedUrl.pathname)
+
+    const safePath = validatePath(pathname, staticDir)
+    if (!safePath) {
+      res.writeHead(403, { 'Content-Type': 'text/plain; charset=utf-8' })
+      res.end('403')
+      return
+    }
+
+    const fileServed = await serveStaticFile(safePath, req, res)
+
+    if (!fileServed) {
+      await serveHTMLPage(pathname, staticDir, req, res)
+    }
+  } catch (error) {
+    console.error('[Ryunix Server Error]:', error.message)
+    res.writeHead(500, { 'Content-Type': 'text/plain; charset=utf-8' })
+    res.end('500')
+  }
+}
+
+const httpServ = http.createServer(requestHandler)
+
+export default httpServ

package/webpack/utils/config.cjs

@@ -67,7 +67,6 @@ const DEFAULT_SSG_SITEMAP_SETTINGS = {
   priority: '0.7',
 }
 
-
 // ============================================================================
 // Configuration Builder
 // ============================================================================
@@ -171,5 +170,4 @@ const defaultSettings = {
   },
 }
 
-
 module.exports = defaultSettings

package/webpack/utils/ssg.mjs

@@ -9,7 +9,7 @@ import path from 'path'
 /**
  * Extract valid routes for SSG from routes configuration
  * Filters out dynamic routes and special routes
- * 
+ *
  * @param {Array} routes - Array of route objects
  * @returns {Array} - Array of valid SSG routes
  */
@@ -46,7 +46,7 @@ const extractSSGRoutes = (routes) => {
 
 /**
  * Generate robots.txt content
- * 
+ *
  * @param {string} baseURL - Base URL of the site
  * @param {Object} options - Configuration options
  * @param {Array<string>} options.disallow - Paths to disallow
@@ -73,7 +73,7 @@ const generateRobotsTxt = (baseURL, options = {}) => {
 
 /**
  * Generate XML sitemap with all routes
- * 
+ *
  * @param {Array} routes - Array of route objects
  * @param {string} baseURL - Base URL of the site
  * @param {Object} defaultSettings - Default sitemap settings
@@ -115,7 +115,7 @@ ${urls}
 
 /**
  * Generate HTML meta tags from metadata object
- * 
+ *
  * @param {Object} meta - Metadata object
  * @param {Object} defaultMeta - Default metadata
  * @returns {string} - HTML meta tags
@@ -181,7 +181,7 @@ const generateMetaTags = (meta, defaultMeta = {}) => {
 
 /**
  * Prerender a route to static HTML
- * 
+ *
  * @param {Object} route - Route object
  * @param {string} template - HTML template
  * @param {Object} config - Configuration object
@@ -194,24 +194,15 @@ const prerenderRoute = async (route, template, config) => {
 
   // Replace title - use route meta or default
   const pageTitle = meta.title || defaultMeta.title || 'Ryunix App'
-  html = html.replace(
-    /<title>.*?<\/title>/,
-    `<title>${pageTitle}</title>`,
-  )
+  html = html.replace(/<title>.*?<\/title>/, `<title>${pageTitle}</title>`)
 
   // Generate and add meta tags
   const metaTags = generateMetaTags(meta, defaultMeta)
 
   // Remove existing meta tags (except framework/mode) and duplicate favicon
   // Remove all meta tags except framework and mode
-  html = html.replace(
-    /<meta\s+name="(?!framework|mode)[^"]*"[^>]*>/gi,
-    ''
-  )
-  html = html.replace(
-    /<meta\s+property="[^"]*"[^>]*>/gi,
-    ''
-  )
+  html = html.replace(/<meta\s+name="(?!framework|mode)[^"]*"[^>]*>/gi, '')
+  html = html.replace(/<meta\s+property="[^"]*"[^>]*>/gi, '')
 
   // Remove duplicate favicon links (keep only first one)
   const faviconMatches = html.match(/<link\s+rel="icon"[^>]*>/gi)
@@ -285,7 +276,7 @@ const prerenderRoute = async (route, template, config) => {
 /**
  * Full SSG build process
  * Generates prerendered HTML, sitemap, and robots.txt
- * 
+ *
  * @param {Array} routesConfig - Routes configuration
  * @param {Object} config - Site configuration
  * @param {string} buildDir - Build output directory
@@ -295,7 +286,6 @@ const buildSSG = async (routesConfig, config, buildDir) => {
   const routes = extractSSGRoutes(routesConfig)
 
   if (routes.length === 0) {
-
     return
   }
 

package/webpack/utils/ssgPlugin.mjs

@@ -1,7 +1,7 @@
 /**
  * Ryunix Routes Plugin - SSG Manifest Generator
  * Extracts routes from routes.ryx file and generates manifest for static site generation
- * 
+ *
  * Features:
  * - Template literal support (`/docs/${var.field}`)
  * - Frontmatter extraction from MDX files
@@ -24,39 +24,31 @@ class RyunixRoutesPlugin {
     compiler.hooks.emit.tapAsync(
       'RyunixRoutesPlugin',
       (compilation, callback) => {
-
-
         // Skip in development mode
         if (compiler.options.mode !== 'production') {
           callback()
           return
         }
 
-
-
         const routesFile = path.resolve(process.cwd(), this.routesPath)
 
         if (!fs.existsSync(routesFile)) {
-          console.log(
-            '[SSG] ❌ The route file was not found:', this.routesPath,
-          )
+          console.log('[SSG] ❌ The route file was not found:', this.routesPath)
           callback()
           return
         }
 
-
         try {
           const content = fs.readFileSync(routesFile, 'utf-8')
 
           this.extractFrontmatter(content, path.dirname(routesFile))
 
-
-
           const routes = this.parseRoutes(content)
 
-
           // Count routes with meta
-          const routesWithMeta = routes.filter(r => r.meta && Object.keys(r.meta).length > 0)
+          const routesWithMeta = routes.filter(
+            (r) => r.meta && Object.keys(r.meta).length > 0,
+          )
 
           const manifest = JSON.stringify(routes, null, 2)
           const outputPath = path.resolve(process.cwd(), this.outputPath)
@@ -64,10 +56,7 @@ class RyunixRoutesPlugin {
           fs.mkdirSync(path.dirname(outputPath), { recursive: true })
           fs.writeFileSync(outputPath, manifest)
 
-
-
           console.log('✅ [SSG Plugin] Process successfully completed')
-
         } catch (error) {
           console.error('\n' + '='.repeat(70))
           console.error('[SSG] ❌ ERROR generating route manifest:')
@@ -98,7 +87,6 @@ class RyunixRoutesPlugin {
       // Resolve absolute path
       const absolutePath = path.resolve(baseDir, mdxPath)
 
-
       if (!fs.existsSync(absolutePath)) {
         if (this.debug) {
           console.warn(`⚠️  File not found: ${absolutePath}`)
@@ -112,7 +100,6 @@ class RyunixRoutesPlugin {
 
         // Remove BOM if present
         if (mdxContent.charCodeAt(0) === 0xfeff) {
-
           mdxContent = mdxContent.slice(1)
         }
 
@@ -120,17 +107,11 @@ class RyunixRoutesPlugin {
 
         if (Object.keys(frontmatter).length > 0) {
           this.frontmatterCache.set(alias, frontmatter)
-
-        }  
+        }
       } catch (error) {
-        console.error(
-          `❌ Error reading ${absolutePath}:`,
-          error.message,
-        )
+        console.error(`❌ Error reading ${absolutePath}:`, error.message)
       }
     }
-
-
   }
 
   /**
@@ -230,7 +211,8 @@ class RyunixRoutesPlugin {
     const routes = []
 
     // Match route objects - capture the entire object
-    const routeRegex = /\{\s*path:\s*[`"'][^`"']*[`"'](?:\s*\|\|\s*[`"'][^`"']*[`"'])?\s*,[\s\S]*?\}/g
+    const routeRegex =
+      /\{\s*path:\s*[`"'][^`"']*[`"'](?:\s*\|\|\s*[`"'][^`"']*[`"'])?\s*,[\s\S]*?\}/g
     let match
 
     while ((match = routeRegex.exec(content)) !== null) {
@@ -258,14 +240,11 @@ class RyunixRoutesPlugin {
 
       // Skip dynamic routes and wildcards
       if (evaluatedPath.includes(':') || evaluatedPath === '*') {
-
         continue
       }
 
       // Check for noRenderLink early
-      const noRenderLinkMatch = routeBlock.match(
-        /noRenderLink:\s*([^,}\s]+)/,
-      )
+      const noRenderLinkMatch = routeBlock.match(/noRenderLink:\s*([^,}\s]+)/)
       if (noRenderLinkMatch) {
         const noRenderValue = this.evaluateExpression(
           noRenderLinkMatch[1].trim(),
@@ -280,7 +259,6 @@ class RyunixRoutesPlugin {
 
       // Check for NotFound property
       if (routeBlock.includes('NotFound:')) {
-
         continue
       }
 
@@ -293,8 +271,6 @@ class RyunixRoutesPlugin {
       const metaContent = this.extractMetaObject(routeBlock)
 
       if (metaContent) {
-
-
         route.meta = {}
 
         // Temporalmente activar debug para esta ruta
@@ -307,16 +283,11 @@ class RyunixRoutesPlugin {
         this.extractField(metaContent, 'image', route.meta)
         this.extractField(metaContent, 'author', route.meta)
         this.extractField(metaContent, 'canonical', route.meta)
-
-
       } else {
         console.log(`   ❌ No object meta found in route: ${evaluatedPath}`)
-
       }
 
       routes.push(route)
-
-
     }
 
     return routes
@@ -526,7 +497,7 @@ class RyunixRoutesPlugin {
     // Only add field if value is meaningful
     if (value !== undefined && value !== null && value !== '') {
       target[fieldName] = value
-    } 
+    }
   }
 
   /**

package/webpack/webpack.config.mjs

@@ -70,7 +70,7 @@ export default {
   },
   context: resolveApp(dir, config.webpack.root),
   entry: './main.ryx',
-  devtool: config.webpack.production ? 'source-map' : false,
+  devtool: config.webpack.production ? false : 'source-map',
   output: {
     path: resolveApp(dir, `${config.webpack.output.buildDirectory}/static`),
     publicPath: '/',