kempo-server 1.8.0 → 1.8.1

package/dist/router.js

@@ -1 +1 @@
-import path from"path";import{readFile}from"fs/promises";import{pathToFileURL}from"url";import defaultConfig from"./defaultConfig.js";import getFiles from"./getFiles.js";import findFile from"./findFile.js";import serveFile from"./serveFile.js";import MiddlewareRunner from"./middlewareRunner.js";import ModuleCache from"./moduleCache.js";import{corsMiddleware,compressionMiddleware,rateLimitMiddleware,securityMiddleware,loggingMiddleware}from"./builtinMiddleware.js";export default async(flags,log)=>{log("Initializing router",3);const rootPath=path.isAbsolute(flags.root)?flags.root:path.join(process.cwd(),flags.root);log(`Root path: ${rootPath}`,3);let config=defaultConfig;try{const configFileName=flags.config||".config.json",configPath=path.isAbsolute(configFileName)?configFileName:path.join(rootPath,configFileName);if(log(`Config file name: ${configFileName}`,3),log(`Config path: ${configPath}`,3),path.isAbsolute(configFileName))log("Config file name is absolute, skipping validation",4);else{const relativeConfigPath=path.relative(rootPath,configPath);if(log(`Relative config path: ${relativeConfigPath}`,4),log(`Starts with '..': ${relativeConfigPath.startsWith("..")}`,4),relativeConfigPath.startsWith("..")||path.isAbsolute(relativeConfigPath))throw log("Validation failed - throwing error",4),new Error(`Config file must be within the server root directory. Config path: ${configPath}, Root path: ${rootPath}`);log("Validation passed",4)}log(`Loading config from: ${configPath}`,3);const configContent=await readFile(configPath,"utf8"),userConfig=JSON.parse(configContent);config={...defaultConfig,...userConfig,allowedMimes:{...defaultConfig.allowedMimes,...userConfig.allowedMimes},middleware:{...defaultConfig.middleware,...userConfig.middleware},customRoutes:{...defaultConfig.customRoutes,...userConfig.customRoutes},cache:{...defaultConfig.cache,...userConfig.cache}},log("User config loaded and merged with defaults",3)}catch(e){if(e.message.includes("Config file must be within the server root directory"))throw e;log("Using default config (no config file found)",3)}const dis=new Set(config.disallowedRegex);dis.add("^/\\..*"),dis.add("\\.config$"),dis.add("\\.git/"),config.disallowedRegex=[...dis],log(`Config loaded with ${config.disallowedRegex.length} disallowed patterns`,3);let files=await getFiles(rootPath,config,log);log(`Initial scan found ${files.length} files`,2);const middlewareRunner=new MiddlewareRunner;if(config.middleware?.cors?.enabled&&(middlewareRunner.use(corsMiddleware(config.middleware.cors)),log("CORS middleware enabled",3)),config.middleware?.compression?.enabled&&(middlewareRunner.use(compressionMiddleware(config.middleware.compression)),log("Compression middleware enabled",3)),config.middleware?.rateLimit?.enabled&&(middlewareRunner.use(rateLimitMiddleware(config.middleware.rateLimit)),log("Rate limit middleware enabled",3)),config.middleware?.security?.enabled&&(middlewareRunner.use(securityMiddleware(config.middleware.security)),log("Security middleware enabled",3)),config.middleware?.logging?.enabled&&(middlewareRunner.use(loggingMiddleware(config.middleware.logging,log)),log("Logging middleware enabled",3)),config.middleware?.custom&&config.middleware.custom.length>0){log(`Loading ${config.middleware.custom.length} custom middleware files`,3);for(const middlewarePath of config.middleware.custom)try{const resolvedPath=path.resolve(middlewarePath),customMiddleware=(await import(pathToFileURL(resolvedPath))).default;"function"==typeof customMiddleware?(middlewareRunner.use(customMiddleware(config.middleware)),log(`Custom middleware loaded: ${middlewarePath}`,3)):log(`Custom middleware error: ${middlewarePath} does not export a default function`,1)}catch(error){log(`Custom middleware error for ${middlewarePath}: ${error.message}`,1)}}let moduleCache=null;config.cache?.enabled&&(moduleCache=new ModuleCache(config.cache),log(`Module cache initialized: ${config.cache.maxSize} max modules, ${config.cache.maxMemoryMB}MB limit, ${config.cache.ttlMs}ms TTL`,2));const customRoutes=new Map,wildcardRoutes=new Map;if(config.customRoutes&&Object.keys(config.customRoutes).length>0){log(`Processing ${Object.keys(config.customRoutes).length} custom routes`,3);for(const[urlPath,filePath]of Object.entries(config.customRoutes))if(urlPath.includes("*")){const resolvedPath=path.isAbsolute(filePath)?filePath:path.resolve(rootPath,filePath);wildcardRoutes.set(urlPath,resolvedPath),log(`Wildcard route mapped: ${urlPath} -> ${resolvedPath}`,3)}else{const resolvedPath=path.isAbsolute(filePath)?filePath:path.resolve(rootPath,filePath);customRoutes.set(urlPath,resolvedPath),log(`Custom route mapped: ${urlPath} -> ${resolvedPath}`,3)}}const matchWildcardRoute=(requestPath,pattern)=>{const regexPattern=pattern.replace(/\*\*/g,"(.+)").replace(/\*/g,"([^/]+)");return new RegExp(`^${regexPattern}$`).exec(requestPath)},rescanAttempts=new Map,dynamicNoRescanPaths=new Set,shouldSkipRescan=requestPath=>config.noRescanPaths.some(pattern=>new RegExp(pattern).test(requestPath))?(log(`Skipping rescan for configured pattern: ${requestPath}`,3),!0):!!dynamicNoRescanPaths.has(requestPath)&&(log(`Skipping rescan for dynamically blacklisted path: ${requestPath}`,3),!0),handler=async(req,res)=>{await middlewareRunner.run(req,res,async()=>{const requestPath=req.url.split("?")[0];log(`${req.method} ${requestPath}`,4),log(`customRoutes keys: ${Array.from(customRoutes.keys()).join(", ")}`,4);const normalizePath=p=>{try{let np=decodeURIComponent(p);return np.startsWith("/")||(np="/"+np),np.length>1&&np.endsWith("/")&&(np=np.slice(0,-1)),np}catch(e){log(`Warning: Failed to decode URI component "${p}": ${e.message}`,1);let np=p;return np.startsWith("/")||(np="/"+np),np.length>1&&np.endsWith("/")&&(np=np.slice(0,-1)),np}},normalizedRequestPath=normalizePath(requestPath);log(`Normalized requestPath: ${normalizedRequestPath}`,4);let matchedKey=null;for(const key of customRoutes.keys())if(normalizePath(key)===normalizedRequestPath){matchedKey=key;break}if(matchedKey){const customFilePath=customRoutes.get(matchedKey);log(`Serving custom route: ${normalizedRequestPath} -> ${customFilePath}`,3);try{const{stat:stat}=await import("fs/promises");try{await stat(customFilePath),log(`Custom route file exists: ${customFilePath}`,4)}catch(e){return log(`Custom route file does NOT exist: ${customFilePath}`,1),res.writeHead(404,{"Content-Type":"text/plain"}),void res.end("Custom route file not found")}const fileExtension=path.extname(customFilePath).toLowerCase().slice(1),mimeConfig=config.allowedMimes[fileExtension];let mimeType,encoding;"string"==typeof mimeConfig?(mimeType=mimeConfig,encoding=void 0):(mimeType=mimeConfig?.mime||"application/octet-stream",encoding="utf8"===mimeConfig?.encoding?"utf8":void 0);const fileContent=await readFile(customFilePath,encoding);return log(`Serving custom file as ${mimeType} (${fileContent.length} bytes)`,2),res.writeHead(200,{"Content-Type":mimeType}),void res.end(fileContent)}catch(error){return log(`Error serving custom route ${normalizedRequestPath}: ${error.message}`,1),res.writeHead(500,{"Content-Type":"text/plain"}),void res.end("Internal Server Error")}}const wildcardMatch=(requestPath=>{for(const[pattern,filePath]of wildcardRoutes){const matches=matchWildcardRoute(requestPath,pattern);if(matches)return{filePath:filePath,matches:matches}}return null})(requestPath);if(wildcardMatch){const resolvedFilePath=((filePath,matches)=>{let resolvedPath=filePath,matchIndex=1;for(;resolvedPath.includes("**")&&matchIndex<matches.length;)resolvedPath=resolvedPath.replace("**",matches[matchIndex]),matchIndex++;for(;resolvedPath.includes("*")&&matchIndex<matches.length;)resolvedPath=resolvedPath.replace("*",matches[matchIndex]),matchIndex++;return path.isAbsolute(resolvedPath)?resolvedPath:path.resolve(rootPath,resolvedPath)})(wildcardMatch.filePath,wildcardMatch.matches);log(`Serving wildcard route: ${requestPath} -> ${resolvedFilePath}`,3);try{const fileExtension=path.extname(resolvedFilePath).toLowerCase().slice(1),mimeConfig=config.allowedMimes[fileExtension];let mimeType,encoding;"string"==typeof mimeConfig?(mimeType=mimeConfig,encoding=void 0):(mimeType=mimeConfig?.mime||"application/octet-stream",encoding="utf8"===mimeConfig?.encoding?"utf8":void 0);const fileContent=await readFile(resolvedFilePath,encoding);return log(`Serving wildcard file as ${mimeType} (${fileContent.length} bytes)`,4),res.writeHead(200,{"Content-Type":mimeType}),void res.end(fileContent)}catch(error){return log(`Error serving wildcard route ${requestPath}: ${error.message}`,1),res.writeHead(500,{"Content-Type":"text/plain"}),void res.end("Internal Server Error")}}const served=await serveFile(files,rootPath,requestPath,req.method,config,req,res,log,moduleCache);if(served||!flags.scan||shouldSkipRescan(requestPath))served||(shouldSkipRescan(requestPath)?log(`404 - Skipped rescan for: ${requestPath}`,2):log(`404 - File not found: ${requestPath}`,1),res.writeHead(404,{"Content-Type":"text/plain"}),res.end("Not Found"));else{(requestPath=>{const newAttempts=(rescanAttempts.get(requestPath)||0)+1;rescanAttempts.set(requestPath,newAttempts),newAttempts>=config.maxRescanAttempts&&(dynamicNoRescanPaths.add(requestPath),log(`Path ${requestPath} added to dynamic blacklist after ${newAttempts} failed attempts`,1)),log(`Rescan attempt ${newAttempts}/${config.maxRescanAttempts} for: ${requestPath}`,3)})(requestPath),log("File not found, rescanning directory...",1),files=await getFiles(rootPath,config,log),log(`Rescan found ${files.length} files`,2);await serveFile(files,rootPath,requestPath,req.method,config,req,res,log,moduleCache)||(log(`404 - File not found after rescan: ${requestPath}`,1),res.writeHead(404,{"Content-Type":"text/plain"}),res.end("Not Found"))}})};return handler.moduleCache=moduleCache,handler.getStats=()=>moduleCache?.getStats()||null,handler.logCacheStats=()=>moduleCache?.logStats(log),handler.clearCache=()=>moduleCache?.clear(),handler};
+import path from"path";import{readFile}from"fs/promises";import{pathToFileURL}from"url";import defaultConfig from"./defaultConfig.js";import getFiles from"./getFiles.js";import findFile from"./findFile.js";import serveFile from"./serveFile.js";import MiddlewareRunner from"./middlewareRunner.js";import ModuleCache from"./moduleCache.js";import{corsMiddleware,compressionMiddleware,rateLimitMiddleware,securityMiddleware,loggingMiddleware}from"./builtinMiddleware.js";export default async(flags,log)=>{log("Initializing router",3);const rootPath=path.isAbsolute(flags.root)?flags.root:path.join(process.cwd(),flags.root);log(`Root path: ${rootPath}`,3);let config=defaultConfig;try{const configFileName=flags.config||".config.json",configPath=path.isAbsolute(configFileName)?configFileName:path.join(rootPath,configFileName);if(log(`Config file name: ${configFileName}`,3),log(`Config path: ${configPath}`,3),path.isAbsolute(configFileName))log("Config file name is absolute, skipping validation",4);else{const relativeConfigPath=path.relative(rootPath,configPath);if(log(`Relative config path: ${relativeConfigPath}`,4),log(`Starts with '..': ${relativeConfigPath.startsWith("..")}`,4),relativeConfigPath.startsWith("..")||path.isAbsolute(relativeConfigPath))throw log("Validation failed - throwing error",4),new Error(`Config file must be within the server root directory. Config path: ${configPath}, Root path: ${rootPath}`);log("Validation passed",4)}log(`Loading config from: ${configPath}`,3);const configContent=await readFile(configPath,"utf8"),userConfig=JSON.parse(configContent);config={...defaultConfig,...userConfig,allowedMimes:{...defaultConfig.allowedMimes,...userConfig.allowedMimes},middleware:{...defaultConfig.middleware,...userConfig.middleware},customRoutes:{...defaultConfig.customRoutes,...userConfig.customRoutes},cache:{...defaultConfig.cache,...userConfig.cache}},log("User config loaded and merged with defaults",3)}catch(e){if(e.message.includes("Config file must be within the server root directory"))throw e;log("Using default config (no config file found)",3)}const dis=new Set(config.disallowedRegex);dis.add("^/\\..*"),dis.add("\\.config$"),dis.add("\\.git/"),config.disallowedRegex=[...dis],log(`Config loaded with ${config.disallowedRegex.length} disallowed patterns`,3);let files=await getFiles(rootPath,config,log);log(`Initial scan found ${files.length} files`,2);const middlewareRunner=new MiddlewareRunner;if(config.middleware?.cors?.enabled&&(middlewareRunner.use(corsMiddleware(config.middleware.cors)),log("CORS middleware enabled",3)),config.middleware?.compression?.enabled&&(middlewareRunner.use(compressionMiddleware(config.middleware.compression)),log("Compression middleware enabled",3)),config.middleware?.rateLimit?.enabled&&(middlewareRunner.use(rateLimitMiddleware(config.middleware.rateLimit)),log("Rate limit middleware enabled",3)),config.middleware?.security?.enabled&&(middlewareRunner.use(securityMiddleware(config.middleware.security)),log("Security middleware enabled",3)),config.middleware?.logging?.enabled&&(middlewareRunner.use(loggingMiddleware(config.middleware.logging,log)),log("Logging middleware enabled",3)),config.middleware?.custom&&config.middleware.custom.length>0){log(`Loading ${config.middleware.custom.length} custom middleware files`,3);for(const middlewarePath of config.middleware.custom)try{const resolvedPath=path.resolve(middlewarePath),customMiddleware=(await import(pathToFileURL(resolvedPath))).default;"function"==typeof customMiddleware?(middlewareRunner.use(customMiddleware(config.middleware)),log(`Custom middleware loaded: ${middlewarePath}`,3)):log(`Custom middleware error: ${middlewarePath} does not export a default function`,1)}catch(error){log(`Custom middleware error for ${middlewarePath}: ${error.message}`,1)}}let moduleCache=null;config.cache?.enabled&&(moduleCache=new ModuleCache(config.cache),log(`Module cache initialized: ${config.cache.maxSize} max modules, ${config.cache.maxMemoryMB}MB limit, ${config.cache.ttlMs}ms TTL`,2));const customRoutes=new Map,wildcardRoutes=new Map;if(config.customRoutes&&Object.keys(config.customRoutes).length>0){log(`Processing ${Object.keys(config.customRoutes).length} custom routes`,3);for(const[urlPath,filePath]of Object.entries(config.customRoutes))if(urlPath.includes("*")){const resolvedPath=path.isAbsolute(filePath)?filePath:path.resolve(rootPath,filePath);wildcardRoutes.set(urlPath,resolvedPath),log(`Wildcard route mapped: ${urlPath} -> ${resolvedPath}`,3)}else{const resolvedPath=path.isAbsolute(filePath)?filePath:path.resolve(rootPath,filePath);customRoutes.set(urlPath,resolvedPath),log(`Custom route mapped: ${urlPath} -> ${resolvedPath}`,3)}}const matchWildcardRoute=(requestPath,pattern)=>{const regexPattern=pattern.replace(/\*\*/g,"(.+)").replace(/\*/g,"([^/]+)");return new RegExp(`^${regexPattern}$`).exec(requestPath)},rescanAttempts=new Map,dynamicNoRescanPaths=new Set,shouldSkipRescan=requestPath=>config.noRescanPaths.some(pattern=>new RegExp(pattern).test(requestPath))?(log(`Skipping rescan for configured pattern: ${requestPath}`,3),!0):!!dynamicNoRescanPaths.has(requestPath)&&(log(`Skipping rescan for dynamically blacklisted path: ${requestPath}`,3),!0),handler=async(req,res)=>{await middlewareRunner.run(req,res,async()=>{const requestPath=req.url.split("?")[0];log(`${req.method} ${requestPath}`,4),log(`customRoutes keys: ${Array.from(customRoutes.keys()).join(", ")}`,4);const normalizePath=p=>{try{let np=decodeURIComponent(p);return np.startsWith("/")||(np="/"+np),np.length>1&&np.endsWith("/")&&(np=np.slice(0,-1)),np}catch(e){log(`Warning: Failed to decode URI component "${p}": ${e.message}`,1);let np=p;return np.startsWith("/")||(np="/"+np),np.length>1&&np.endsWith("/")&&(np=np.slice(0,-1)),np}},normalizedRequestPath=normalizePath(requestPath);log(`Normalized requestPath: ${normalizedRequestPath}`,4);let matchedKey=null;for(const key of customRoutes.keys())if(normalizePath(key)===normalizedRequestPath){matchedKey=key;break}if(matchedKey){const customFilePath=customRoutes.get(matchedKey);log(`Serving custom route: ${normalizedRequestPath} -> ${customFilePath}`,3);try{const{stat:stat}=await import("fs/promises");try{await stat(customFilePath),log(`Custom route file exists: ${customFilePath}`,4)}catch(e){return log(`Custom route file does NOT exist: ${customFilePath}`,1),res.writeHead(404,{"Content-Type":"text/plain"}),void res.end("Custom route file not found")}const fileExtension=path.extname(customFilePath).toLowerCase().slice(1),mimeConfig=config.allowedMimes[fileExtension];let mimeType,encoding;"string"==typeof mimeConfig?(mimeType=mimeConfig,encoding=mimeType.startsWith("text/")?"utf8":void 0):(mimeType=mimeConfig?.mime||"application/octet-stream",encoding="utf8"===mimeConfig?.encoding?"utf8":void 0);const fileContent=await readFile(customFilePath,encoding);log(`Serving custom file as ${mimeType} (${fileContent.length} bytes)`,2);const contentType="utf8"===encoding&&mimeType.startsWith("text/")?`${mimeType}; charset=utf-8`:mimeType;return res.writeHead(200,{"Content-Type":contentType}),void res.end(fileContent)}catch(error){return log(`Error serving custom route ${normalizedRequestPath}: ${error.message}`,1),res.writeHead(500,{"Content-Type":"text/plain"}),void res.end("Internal Server Error")}}const wildcardMatch=(requestPath=>{for(const[pattern,filePath]of wildcardRoutes){const matches=matchWildcardRoute(requestPath,pattern);if(matches)return{filePath:filePath,matches:matches}}return null})(requestPath);if(wildcardMatch){const resolvedFilePath=((filePath,matches)=>{let resolvedPath=filePath,matchIndex=1;for(;resolvedPath.includes("**")&&matchIndex<matches.length;)resolvedPath=resolvedPath.replace("**",matches[matchIndex]),matchIndex++;for(;resolvedPath.includes("*")&&matchIndex<matches.length;)resolvedPath=resolvedPath.replace("*",matches[matchIndex]),matchIndex++;return path.isAbsolute(resolvedPath)?resolvedPath:path.resolve(rootPath,resolvedPath)})(wildcardMatch.filePath,wildcardMatch.matches);log(`Serving wildcard route: ${requestPath} -> ${resolvedFilePath}`,3);try{const fileExtension=path.extname(resolvedFilePath).toLowerCase().slice(1),mimeConfig=config.allowedMimes[fileExtension];let mimeType,encoding;"string"==typeof mimeConfig?(mimeType=mimeConfig,encoding=mimeType.startsWith("text/")?"utf8":void 0):(mimeType=mimeConfig?.mime||"application/octet-stream",encoding="utf8"===mimeConfig?.encoding?"utf8":void 0);const fileContent=await readFile(resolvedFilePath,encoding);log(`Serving wildcard file as ${mimeType} (${fileContent.length} bytes)`,4);const contentType="utf8"===encoding&&mimeType.startsWith("text/")?`${mimeType}; charset=utf-8`:mimeType;return res.writeHead(200,{"Content-Type":contentType}),void res.end(fileContent)}catch(error){return log(`Error serving wildcard route ${requestPath}: ${error.message}`,1),res.writeHead(500,{"Content-Type":"text/plain"}),void res.end("Internal Server Error")}}const served=await serveFile(files,rootPath,requestPath,req.method,config,req,res,log,moduleCache);if(served||!flags.scan||shouldSkipRescan(requestPath))served||(shouldSkipRescan(requestPath)?log(`404 - Skipped rescan for: ${requestPath}`,2):log(`404 - File not found: ${requestPath}`,1),res.writeHead(404,{"Content-Type":"text/plain"}),res.end("Not Found"));else{(requestPath=>{const newAttempts=(rescanAttempts.get(requestPath)||0)+1;rescanAttempts.set(requestPath,newAttempts),newAttempts>=config.maxRescanAttempts&&(dynamicNoRescanPaths.add(requestPath),log(`Path ${requestPath} added to dynamic blacklist after ${newAttempts} failed attempts`,1)),log(`Rescan attempt ${newAttempts}/${config.maxRescanAttempts} for: ${requestPath}`,3)})(requestPath),log("File not found, rescanning directory...",1),files=await getFiles(rootPath,config,log),log(`Rescan found ${files.length} files`,2);await serveFile(files,rootPath,requestPath,req.method,config,req,res,log,moduleCache)||(log(`404 - File not found after rescan: ${requestPath}`,1),res.writeHead(404,{"Content-Type":"text/plain"}),res.end("Not Found"))}})};return handler.moduleCache=moduleCache,handler.getStats=()=>moduleCache?.getStats()||null,handler.logCacheStats=()=>moduleCache?.logStats(log),handler.clearCache=()=>moduleCache?.clear(),handler};

package/dist/serveFile.js

@@ -1 +1 @@
-import path from"path";import{readFile,stat}from"fs/promises";import{pathToFileURL}from"url";import findFile from"./findFile.js";import createRequestWrapper from"./requestWrapper.js";import createResponseWrapper from"./responseWrapper.js";export default async(files,rootPath,requestPath,method,config,req,res,log,moduleCache=null)=>{log(`Attempting to serve: ${requestPath}`,3);const[file,params]=await findFile(files,rootPath,requestPath,method,log);if(!file)return log(`No file found for: ${requestPath}`,3),!1;const fileName=path.basename(file);if(log(`Found file: ${file}`,2),config.routeFiles.includes(fileName)){log(`Executing route file: ${fileName}`,2);try{let module;if(moduleCache&&config.cache?.enabled){const fileStats=await stat(file);if(module=moduleCache.get(file,fileStats),module)log(`Using cached module: ${fileName}`,3);else{const fileUrl=pathToFileURL(file).href+`?t=${Date.now()}`;log(`Loading module from: ${fileUrl}`,3),module=await import(fileUrl);const estimatedSizeKB=fileStats.size/1024;moduleCache.set(file,module,fileStats,estimatedSizeKB),log(`Cached module: ${fileName} (${estimatedSizeKB.toFixed(1)}KB)`,3)}}else{const fileUrl=pathToFileURL(file).href+`?t=${Date.now()}`;log(`Loading module from: ${fileUrl}`,3),module=await import(fileUrl)}if("function"==typeof module.default){log(`Executing route function with params: ${JSON.stringify(params)}`,3);const enhancedRequest=createRequestWrapper(req,params),enhancedResponse=createResponseWrapper(res);return moduleCache&&(enhancedRequest._kempoCache=moduleCache),await module.default(enhancedRequest,enhancedResponse),log(`Route executed successfully: ${fileName}`,2),!0}return log(`Route file does not export a function: ${fileName}`,0),res.writeHead(500,{"Content-Type":"text/plain"}),res.end("Route file does not export a function"),!0}catch(error){return log(`Error loading route file ${fileName}: ${error.message}`,0),res.writeHead(500,{"Content-Type":"text/plain"}),res.end("Internal Server Error"),!0}}else{log(`Serving static file: ${fileName}`,2);try{const fileExtension=path.extname(file).toLowerCase().slice(1),mimeConfig=config.allowedMimes[fileExtension];let mimeType,encoding;"string"==typeof mimeConfig?(mimeType=mimeConfig,encoding=void 0):(mimeType=mimeConfig?.mime||"application/octet-stream",encoding="utf8"===mimeConfig?.encoding?"utf8":void 0);const fileContent=await readFile(file,encoding);return log(`Serving ${file} as ${mimeType} (${fileContent.length} bytes)`,2),res.writeHead(200,{"Content-Type":mimeType}),res.end(fileContent),!0}catch(error){return log(`Error reading file ${file}: ${error.message}`,0),res.writeHead(500,{"Content-Type":"text/plain"}),res.end("Internal Server Error"),!0}}};
+import path from"path";import{readFile,stat}from"fs/promises";import{pathToFileURL}from"url";import findFile from"./findFile.js";import createRequestWrapper from"./requestWrapper.js";import createResponseWrapper from"./responseWrapper.js";export default async(files,rootPath,requestPath,method,config,req,res,log,moduleCache=null)=>{log(`Attempting to serve: ${requestPath}`,3);const[file,params]=await findFile(files,rootPath,requestPath,method,log);if(!file)return log(`No file found for: ${requestPath}`,3),!1;const fileName=path.basename(file);if(log(`Found file: ${file}`,2),config.routeFiles.includes(fileName)){log(`Executing route file: ${fileName}`,2);try{let module;if(moduleCache&&config.cache?.enabled){const fileStats=await stat(file);if(module=moduleCache.get(file,fileStats),module)log(`Using cached module: ${fileName}`,3);else{const fileUrl=pathToFileURL(file).href+`?t=${Date.now()}`;log(`Loading module from: ${fileUrl}`,3),module=await import(fileUrl);const estimatedSizeKB=fileStats.size/1024;moduleCache.set(file,module,fileStats,estimatedSizeKB),log(`Cached module: ${fileName} (${estimatedSizeKB.toFixed(1)}KB)`,3)}}else{const fileUrl=pathToFileURL(file).href+`?t=${Date.now()}`;log(`Loading module from: ${fileUrl}`,3),module=await import(fileUrl)}if("function"==typeof module.default){log(`Executing route function with params: ${JSON.stringify(params)}`,3);const enhancedRequest=createRequestWrapper(req,params),enhancedResponse=createResponseWrapper(res);return moduleCache&&(enhancedRequest._kempoCache=moduleCache),await module.default(enhancedRequest,enhancedResponse),log(`Route executed successfully: ${fileName}`,2),!0}return log(`Route file does not export a function: ${fileName}`,0),res.writeHead(500,{"Content-Type":"text/plain"}),res.end("Route file does not export a function"),!0}catch(error){return log(`Error loading route file ${fileName}: ${error.message}`,0),res.writeHead(500,{"Content-Type":"text/plain"}),res.end("Internal Server Error"),!0}}else{log(`Serving static file: ${fileName}`,2);try{const fileExtension=path.extname(file).toLowerCase().slice(1),mimeConfig=config.allowedMimes[fileExtension];let mimeType,encoding;"string"==typeof mimeConfig?(mimeType=mimeConfig,encoding=mimeType.startsWith("text/")?"utf8":void 0):(mimeType=mimeConfig?.mime||"application/octet-stream",encoding="utf8"===mimeConfig?.encoding?"utf8":void 0);const fileContent=await readFile(file,encoding);log(`Serving ${file} as ${mimeType} (${fileContent.length} bytes)`,2);const contentType="utf8"===encoding&&mimeType.startsWith("text/")?`${mimeType}; charset=utf-8`:mimeType;return res.writeHead(200,{"Content-Type":contentType}),res.end(fileContent),!0}catch(error){return log(`Error reading file ${file}: ${error.message}`,0),res.writeHead(500,{"Content-Type":"text/plain"}),res.end("Internal Server Error"),!0}}};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "kempo-server",
   "type": "module",
-  "version": "1.8.0",
+  "version": "1.8.1",
   "description": "A lightweight, zero-dependency, file based routing server.",
   "main": "dist/index.js",
   "exports": {

package/src/router.js

@@ -315,14 +315,19 @@ export default async (flags, log) => {
           let mimeType, encoding;
           if (typeof mimeConfig === 'string') {
             mimeType = mimeConfig;
-            encoding = undefined;
+            // Default to UTF-8 for text MIME types
+            encoding = mimeType.startsWith('text/') ? 'utf8' : undefined;
           } else {
             mimeType = mimeConfig?.mime || 'application/octet-stream';
             encoding = mimeConfig?.encoding === 'utf8' ? 'utf8' : undefined;
           }
           const fileContent = await readFile(customFilePath, encoding);
           log(`Serving custom file as ${mimeType} (${fileContent.length} bytes)`, 2);
-          res.writeHead(200, { 'Content-Type': mimeType });
+          // Add charset=utf-8 for text MIME types when using UTF-8 encoding
+          const contentType = encoding === 'utf8' && mimeType.startsWith('text/') 
+            ? `${mimeType}; charset=utf-8` 
+            : mimeType;
+          res.writeHead(200, { 'Content-Type': contentType });
           res.end(fileContent);
           return; // Successfully served custom route
         } catch (error) {
@@ -344,14 +349,19 @@ export default async (flags, log) => {
           let mimeType, encoding;
           if (typeof mimeConfig === 'string') {
             mimeType = mimeConfig;
-            encoding = undefined;
+            // Default to UTF-8 for text MIME types
+            encoding = mimeType.startsWith('text/') ? 'utf8' : undefined;
           } else {
             mimeType = mimeConfig?.mime || 'application/octet-stream';
             encoding = mimeConfig?.encoding === 'utf8' ? 'utf8' : undefined;
           }
           const fileContent = await readFile(resolvedFilePath, encoding);
           log(`Serving wildcard file as ${mimeType} (${fileContent.length} bytes)`, 4);
-          res.writeHead(200, { 'Content-Type': mimeType });
+          // Add charset=utf-8 for text MIME types when using UTF-8 encoding
+          const contentType = encoding === 'utf8' && mimeType.startsWith('text/') 
+            ? `${mimeType}; charset=utf-8` 
+            : mimeType;
+          res.writeHead(200, { 'Content-Type': contentType });
           res.end(fileContent);
           return; // Successfully served wildcard route
         } catch (error) {

package/src/serveFile.js

@@ -87,14 +87,19 @@ export default async (files, rootPath, requestPath, method, config, req, res, lo
       let mimeType, encoding;
       if (typeof mimeConfig === 'string') {
         mimeType = mimeConfig;
-        encoding = undefined;
+        // Default to UTF-8 for text MIME types
+        encoding = mimeType.startsWith('text/') ? 'utf8' : undefined;
       } else {
         mimeType = mimeConfig?.mime || 'application/octet-stream';
         encoding = mimeConfig?.encoding === 'utf8' ? 'utf8' : undefined;
       }
       const fileContent = await readFile(file, encoding);
       log(`Serving ${file} as ${mimeType} (${fileContent.length} bytes)`, 2);
-      res.writeHead(200, { 'Content-Type': mimeType });
+      // Add charset=utf-8 for text MIME types when using UTF-8 encoding
+      const contentType = encoding === 'utf8' && mimeType.startsWith('text/') 
+        ? `${mimeType}; charset=utf-8` 
+        : mimeType;
+      res.writeHead(200, { 'Content-Type': contentType });
       res.end(fileContent);
       return true; // Successfully served
     } catch (error) {

package/tests/builtinMiddleware-cors.node-test.js

@@ -1,5 +1,6 @@
 import {corsMiddleware} from '../src/builtinMiddleware.js';
-import {createMockReq, createMockRes} from './test-utils.js';
+import {createMockReq} from './utils/mock-req.js';
+import {createMockRes} from './utils/mock-res.js';
 
 export default {
   'cors origin array and non-OPTIONS continues to next': async ({pass, fail}) => {

package/tests/builtinMiddleware.node-test.js

@@ -1,5 +1,9 @@
 import http from 'http';
-import {createMockReq, createMockRes, bigString, gzipSize, setEnv} from './test-utils.js';
+import {createMockReq} from './utils/mock-req.js';
+import {createMockRes} from './utils/mock-res.js';
+import {bigString} from './utils/string-utils.js';
+import {gzipSize} from './utils/compression.js';
+import {setEnv} from './utils/env.js';
 import {corsMiddleware, compressionMiddleware, rateLimitMiddleware, securityMiddleware, loggingMiddleware} from '../src/builtinMiddleware.js';
 
 export default {

package/tests/config-flag-cli.node-test.js

@@ -1,6 +1,10 @@
-import {startNode, randomPort, httpGet, withTempDir, write} from './test-utils.js';
+import {startNode} from './utils/process.js';
+import {randomPort} from './utils/port.js';
+import {httpGet} from './utils/http.js';
+import {withTempDir} from './utils/temp-dir.js';
+import {write} from './utils/file-writer.js';
 import path from 'path';
-import ensureBuild from './ensure-build.js';
+import ensureBuild from './utils/ensure-build.js';
 
 ensureBuild();
 
@@ -29,8 +33,8 @@ export default {
         if (res.statusCode !== 200) {
           return fail('server should serve file with default config');
         }
-        if (res.headers['content-type'] !== 'text/default') {
-          return fail('should use default config mime type');
+        if (res.headers['content-type'] !== 'text/default; charset=utf-8') {
+          return fail('should use default config mime type with charset');
         }
         if (body.toString() !== 'default config content') {
           return fail('should serve correct content');
@@ -73,8 +77,8 @@ export default {
         if (res.statusCode !== 200) {
           return fail('server should serve file with custom config');
         }
-        if (res.headers['content-type'] !== 'text/custom') {
-          return fail('should use custom config mime type');
+        if (res.headers['content-type'] !== 'text/custom; charset=utf-8') {
+          return fail('should use custom config mime type with charset');
         }
         if (body.toString() !== 'custom config content') {
           return fail('should serve correct content');
@@ -117,8 +121,8 @@ export default {
         if (res.statusCode !== 200) {
           return fail('server should serve file with short flag config');
         }
-        if (res.headers['content-type'] !== 'text/short') {
-          return fail('should use short flag config mime type');
+        if (res.headers['content-type'] !== 'text/short; charset=utf-8') {
+          return fail('should use short flag config mime type with charset');
         }
         if (body.toString() !== 'short flag content') {
           return fail('should serve correct content');
@@ -162,8 +166,8 @@ export default {
         if (res.statusCode !== 200) {
           return fail('server should serve file with absolute path config');
         }
-        if (res.headers['content-type'] !== 'text/absolute') {
-          return fail('should use absolute path config mime type');
+        if (res.headers['content-type'] !== 'text/absolute; charset=utf-8') {
+          return fail('should use absolute path config mime type with charset');
         }
         if (body.toString() !== 'absolute path content') {
           return fail('should serve correct content');
@@ -199,8 +203,8 @@ export default {
         if (res.statusCode !== 200) {
           return fail('server should start with missing config');
         }
-        if (res.headers['content-type'] !== 'text/html') {
-          return fail('should use default mime types');
+        if (res.headers['content-type'] !== 'text/html; charset=utf-8') {
+          return fail('should use default mime types with charset');
         }
         if (!body.toString().includes('<h1>Home</h1>')) {
           return fail('should serve HTML content');
@@ -246,8 +250,8 @@ export default {
         if (res.statusCode !== 200) {
           return fail('custom route should work with config flag');
         }
-        if (res.headers['content-type'] !== 'text/plain') {
-          return fail('should use config mime type');
+        if (res.headers['content-type'] !== 'text/plain; charset=utf-8') {
+          return fail('should use config mime type with charset');
         }
         if (body.toString() !== 'source file content') {
           return fail('should serve custom route content');

package/tests/config-flag.node-test.js

@@ -1,6 +1,9 @@
 import http from 'http';
 import path from 'path';
-import {withTempDir, write, randomPort, httpGet} from './test-utils.js';
+import {withTempDir} from './utils/temp-dir.js';
+import {write} from './utils/file-writer.js';
+import {randomPort} from './utils/port.js';
+import {httpGet} from './utils/http.js';
 import router from '../src/router.js';
 import getFlags from '../src/getFlags.js';
 
@@ -114,8 +117,8 @@ export default {
         if (response.res.statusCode !== 200) {
           return fail('custom mime type should be served');
         }
-        if (response.res.headers['content-type'] !== 'text/custom') {
-          return fail('should use custom mime type');
+        if (response.res.headers['content-type'] !== 'text/custom; charset=utf-8') {
+          return fail('should use custom mime type with charset');
         }
         pass('default config file usage');
       } finally {
@@ -153,8 +156,8 @@ export default {
         if (response.res.statusCode !== 200) {
           return fail('custom config should be loaded');
         }
-        if (response.res.headers['content-type'] !== 'text/special') {
-          return fail('should use custom config mime type');
+        if (response.res.headers['content-type'] !== 'text/special; charset=utf-8') {
+          return fail('should use custom config mime type with charset');
         }
         pass('relative path config file usage');
       } finally {
@@ -193,8 +196,8 @@ export default {
         if (response.res.statusCode !== 200) {
           return fail('absolute config path should work');
         }
-        if (response.res.headers['content-type'] !== 'text/absolute') {
-          return fail('should use absolute config mime type');
+        if (response.res.headers['content-type'] !== 'text/absolute; charset=utf-8') {
+          return fail('should use absolute config mime type with charset');
         }
         pass('absolute path config file usage');
       } finally {
@@ -308,8 +311,8 @@ export default {
         if (customResponse.res.statusCode !== 200) {
           return fail('custom mime type should work');
         }
-        if (customResponse.res.headers['content-type'] !== 'text/custom') {
-          return fail('should use custom mime type');
+        if (customResponse.res.headers['content-type'] !== 'text/custom; charset=utf-8') {
+          return fail('should use custom mime type with charset');
         }
         pass('config merging with defaults');
       } finally {

package/tests/customRoute-outside-root.node-test.js

@@ -2,7 +2,10 @@ import router from '../src/router.js';
 import http from 'http';
 import { writeFile, mkdir } from 'fs/promises';
 import path from 'path';
-import { randomPort, httpGet, withTempDir, write } from './test-utils.js';
+import {randomPort} from './utils/port.js';
+import {httpGet} from './utils/http.js';
+import {withTempDir} from './utils/temp-dir.js';
+import {write} from './utils/file-writer.js';
 
 /*
   This test verifies that a customRoute pointing outside the rootPath is served

package/tests/example-middleware.node-test.js

@@ -1,6 +1,8 @@
 import path from 'path';
 import url from 'url';
-import {createMockReq, createMockRes, setEnv} from './test-utils.js';
+import {createMockReq} from './utils/mock-req.js';
+import {createMockRes} from './utils/mock-res.js';
+import {setEnv} from './utils/env.js';
 
 // import the middleware module by file path to avoid executing index.js
 const examplePath = path.join(process.cwd(), 'tests', 'example-middleware.js');

package/tests/getFiles.node-test.js

@@ -1,7 +1,9 @@
 import getFiles from '../src/getFiles.js';
 import defaultConfig from '../src/defaultConfig.js';
 import path from 'path';
-import {withTestDir, write, log} from './test-utils.js';
+import {withTestDir} from './utils/test-dir.js';
+import {write} from './utils/file-writer.js';
+import {log} from './utils/logging.js';
 
 export default {
   'scans directories recursively and filters by mime and disallowed': async ({pass, fail}) => {

package/tests/index.node-test.js

@@ -1,6 +1,10 @@
-import {startNode, randomPort, httpGet, withTestDir, write} from './test-utils.js';
+import {startNode} from './utils/process.js';
+import {randomPort} from './utils/port.js';
+import {httpGet} from './utils/http.js';
+import {withTestDir} from './utils/test-dir.js';
+import {write} from './utils/file-writer.js';
 import path from 'path';
-import ensureBuild from './ensure-build.js';
+import ensureBuild from './utils/ensure-build.js';
 
 ensureBuild();
 

package/tests/middlewareRunner.node-test.js

@@ -1,5 +1,6 @@
 import MiddlewareRunner from '../src/middlewareRunner.js';
-import {createMockReq, createMockRes} from './test-utils.js';
+import {createMockReq} from './utils/mock-req.js';
+import {createMockRes} from './utils/mock-res.js';
 
 export default {
   'runs middleware in order and calls finalHandler': async ({pass, fail}) => {

package/tests/mimeTypes-merge.node-test.js

@@ -63,24 +63,24 @@ export default {
         if(cssResponse.res.statusCode !== 200){
           return fail('CSS file should be served');
         }
-        if(cssResponse.res.headers['content-type'] !== 'text/css'){
-          return fail(`CSS should have text/css MIME type, got: ${cssResponse.res.headers['content-type']}`);
+        if(cssResponse.res.headers['content-type'] !== 'text/css; charset=utf-8'){
+          return fail(`CSS should have text/css MIME type with charset, got: ${cssResponse.res.headers['content-type']}`);
         }
         
         const jsResponse = await httpGet(`http://localhost:${port}/test.js`);
         if(jsResponse.res.statusCode !== 200){
           return fail('JS file should be served');
         }
-        if(jsResponse.res.headers['content-type'] !== 'text/javascript'){
-          return fail(`JS should have custom text/javascript MIME type, got: ${jsResponse.res.headers['content-type']}`);
+        if(jsResponse.res.headers['content-type'] !== 'text/javascript; charset=utf-8'){
+          return fail(`JS should have custom text/javascript MIME type with charset, got: ${jsResponse.res.headers['content-type']}`);
         }
         
         const htmlResponse = await httpGet(`http://localhost:${port}/test.html`);
         if(htmlResponse.res.statusCode !== 200){
           return fail('HTML file should be served');
         }
-        if(htmlResponse.res.headers['content-type'] !== 'text/html'){
-          return fail(`HTML should have text/html MIME type, got: ${htmlResponse.res.headers['content-type']}`);
+        if(htmlResponse.res.headers['content-type'] !== 'text/html; charset=utf-8'){
+          return fail(`HTML should have text/html MIME type with charset, got: ${htmlResponse.res.headers['content-type']}`);
         }
         
         pass('allowedMimes merges correctly with defaults');
@@ -162,8 +162,8 @@ export default {
       
       try {
         const tests = [
-          { file: 'test.css', expectedType: 'text/css' },
-          { file: 'test.html', expectedType: 'text/html' },
+          { file: 'test.css', expectedType: 'text/css; charset=utf-8' },
+          { file: 'test.html', expectedType: 'text/html; charset=utf-8' },
           { file: 'test.json', expectedType: 'application/json' },
           { file: 'test.svg', expectedType: 'image/svg+xml' },
           { file: 'test.png', expectedType: 'image/png' },

package/tests/requestWrapper.node-test.js

@@ -1,4 +1,4 @@
-import {createMockReq} from './test-utils.js';
+import {createMockReq} from './utils/mock-req.js';
 import createRequestWrapper from '../src/requestWrapper.js';
 
 export default {

package/tests/responseWrapper.node-test.js

@@ -1,4 +1,5 @@
-import {createMockRes, parseCookies} from './test-utils.js';
+import {createMockRes} from './utils/mock-res.js';
+import {parseCookies} from './utils/cookie.js';
 import createResponseWrapper from '../src/responseWrapper.js';
 
 export default {

package/tests/router-middleware.node-test.js

@@ -1,5 +1,7 @@
 import http from 'http';
-import {withTestDir, write, randomPort} from './test-utils.js';
+import {withTestDir} from './utils/test-dir.js';
+import {write} from './utils/file-writer.js';
+import {randomPort} from './utils/port.js';
 import router from '../src/router.js';
 
 export default {

package/tests/router-wildcard-double-asterisk.node-test.js

@@ -1,6 +1,10 @@
 import http from 'http';
 import path from 'path';
-import {withTempDir, write, randomPort, httpGet, log} from './test-utils.js';
+import {withTempDir} from './utils/temp-dir.js';
+import {write} from './utils/file-writer.js';
+import {randomPort} from './utils/port.js';
+import {httpGet} from './utils/http.js';
+import {log} from './utils/logging.js';
 import router from '../src/router.js';
 
 export default {

package/tests/router-wildcard.node-test.js

@@ -1,6 +1,10 @@
 import http from 'http';
 import path from 'path';
-import {withTempDir, write, randomPort, httpGet, log} from './test-utils.js';
+import {withTempDir} from './utils/temp-dir.js';
+import {write} from './utils/file-writer.js';
+import {randomPort} from './utils/port.js';
+import {httpGet} from './utils/http.js';
+import {log} from './utils/logging.js';
 import router from '../src/router.js';
 
 export default {

package/tests/router.node-test.js

@@ -1,6 +1,10 @@
 import http from 'http';
 import path from 'path';
-import {withTestDir, write, randomPort, httpGet, log} from './test-utils.js';
+import {withTestDir} from './utils/test-dir.js';
+import {write} from './utils/file-writer.js';
+import {randomPort} from './utils/port.js';
+import {httpGet} from './utils/http.js';
+import {log} from './utils/logging.js';
 import router from '../src/router.js';
 import defaultConfig from '../src/defaultConfig.js';
 

package/tests/serveFile.node-test.js

@@ -2,7 +2,11 @@ import serveFile from '../src/serveFile.js';
 import findFile from '../src/findFile.js';
 import defaultConfig from '../src/defaultConfig.js';
 import path from 'path';
-import {createMockReq, createMockRes, withTestDir, write, log} from './test-utils.js';
+import {createMockReq} from './utils/mock-req.js';
+import {createMockRes} from './utils/mock-res.js';
+import {withTestDir} from './utils/test-dir.js';
+import {write} from './utils/file-writer.js';
+import {log} from './utils/logging.js';
 
 export default {
   'serves static file with correct mime': async ({pass, fail}) => {
@@ -14,7 +18,7 @@ export default {
         const ok = await serveFile(files, dir, '/index.html', 'GET', cfg, createMockReq(), res, log);
         if(ok !== true) return fail('should serve');
         if(res.statusCode !== 200) return fail('status');
-        if(res.getHeader('Content-Type') !== 'text/html') return fail('mime');
+        if(res.getHeader('Content-Type') !== 'text/html; charset=utf-8') return fail('mime');
       });
       pass('static');
     } catch(e){ fail(e.message); }

package/tests/utils/compression.js

@@ -0,0 +1,4 @@
+export const gzipSize = async (buf) => {
+  const {gzip} = await import('zlib');
+  return new Promise((res, rej) => gzip(buf, (e, out) => e ? rej(e) : res(out.length)));
+};

package/tests/utils/cookie.js

@@ -0,0 +1 @@
+export const parseCookies = (setCookie) => Array.isArray(setCookie) ? setCookie : (setCookie ? [setCookie] : []);

package/tests/utils/env.js

@@ -0,0 +1,6 @@
+export const setEnv = (pairs, fn) => {
+  const prev = {};
+  Object.keys(pairs).forEach(k => { prev[k] = process.env[k]; process.env[k] = pairs[k]; });
+  const restore = () => { Object.keys(pairs).forEach(k => { if(prev[k] === undefined){ delete process.env[k]; } else { process.env[k] = prev[k]; } }); };
+  return fn().finally(restore);
+};

package/tests/utils/file-writer.js

@@ -0,0 +1,9 @@
+import {writeFile, mkdir} from 'fs/promises';
+import path from 'path';
+
+export const write = async (root, rel, content = '') => {
+  const full = path.join(root, rel);
+  await mkdir(path.dirname(full), {recursive: true});
+  await writeFile(full, content);
+  return full;
+};

package/tests/utils/http.js

@@ -0,0 +1,9 @@
+export const httpGet = (url) => new Promise((resolve, reject) => {
+  import('http').then(({get}) => {
+    get(url, res => {
+      const chunks = [];
+      res.on('data', c => chunks.push(c));
+      res.on('end', () => resolve({res, body: Buffer.concat(chunks)}));
+    }).on('error', reject);
+  }).catch(reject);
+});

package/tests/utils/logging.js

@@ -0,0 +1 @@
+export const log = (..._args) => {};

package/tests/utils/mock-req.js

@@ -0,0 +1,19 @@
+import {Readable} from 'stream';
+
+export const createMockReq = ({method = 'GET', url = '/', headers = {}, body = null, remoteAddress = '127.0.0.1'} = {}) => {
+  const stream = new Readable({read(){}});
+  stream.method = method;
+  stream.url = url;
+  stream.headers = headers;
+  stream.socket = {remoteAddress};
+  if(body !== null && body !== undefined){
+    const data = typeof body === 'string' || Buffer.isBuffer(body) ? body : JSON.stringify(body);
+    setImmediate(() => {
+      stream.emit('data', Buffer.from(data));
+      stream.emit('end');
+    });
+  } else {
+    setImmediate(() => stream.emit('end'));
+  }
+  return stream;
+};

package/tests/utils/mock-res.js

@@ -0,0 +1,21 @@
+export const createMockRes = () => {
+  const headers = new Map();
+  let ended = false;
+  let statusCode = 200;
+  const chunks = [];
+  return {
+    get statusCode(){return statusCode;},
+    set statusCode(v){statusCode = v;},
+    setHeader: (k, v) => headers.set(k, v),
+    getHeader: (k) => headers.get(k),
+    writeHead: (code, hdrs = {}) => {
+      statusCode = code;
+      Object.entries(hdrs).forEach(([k, v]) => headers.set(k, v));
+    },
+    write: (chunk) => { if(chunk) chunks.push(Buffer.from(chunk)); return true; },
+    end: (chunk) => { if(chunk) chunks.push(Buffer.from(chunk)); ended = true; },
+    getHeaders: () => Object.fromEntries(headers),
+    getBody: () => Buffer.concat(chunks),
+    isEnded: () => ended
+  };
+};

package/tests/utils/port.js

@@ -0,0 +1 @@
+export const randomPort = () => 1024 + Math.floor(Math.random() * 50000);

package/tests/utils/process.js

@@ -0,0 +1,7 @@
+export const startNode = async (args, options = {}) => {
+  const {spawn} = await import('child_process');
+  const child = spawn(process.execPath, args, {stdio: ['ignore', 'pipe', 'pipe'], ...options});
+  child.stdout.setEncoding('utf8');
+  child.stderr.setEncoding('utf8');
+  return child;
+};

package/tests/utils/string-utils.js

@@ -0,0 +1,3 @@
+export const bigString = (size = 5000) => 'x'.repeat(size);
+
+export const toString = (buf) => Buffer.isBuffer(buf) ? buf.toString() : String(buf);

package/tests/utils/temp-dir.js

@@ -0,0 +1,12 @@
+import {mkdtemp, rm} from 'fs/promises';
+import os from 'os';
+import path from 'path';
+
+export const withTempDir = async (fn) => {
+  const dir = await mkdtemp(path.join(os.tmpdir(), 'kempo-tests-'));
+  try {
+    return await fn(dir);
+  } finally {
+    await rm(dir, {recursive: true, force: true});
+  }
+};

package/tests/utils/test-dir.js

@@ -0,0 +1,24 @@
+import {mkdtemp, rm, cp} from 'fs/promises';
+import os from 'os';
+import path from 'path';
+import {fileURLToPath} from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const TEST_SERVER_ROOT = path.join(__dirname, '..', 'test-server-root');
+
+export const withTestDir = async (fn, {subdir = null} = {}) => {
+  const tempDir = await mkdtemp(path.join(os.tmpdir(), 'kempo-tests-'));
+  try {
+    // Copy the test server root to the temporary directory
+    await cp(TEST_SERVER_ROOT, tempDir, {recursive: true});
+    let workingDir = tempDir;
+    
+    if (subdir) {
+      workingDir = path.join(tempDir, subdir);
+    }
+    
+    return await fn(workingDir);
+  } finally {
+    await rm(tempDir, {recursive: true, force: true});
+  }
+};

package/tests/utils/test-file-path.js

@@ -0,0 +1,9 @@
+import path from 'path';
+import {fileURLToPath} from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const TEST_SERVER_ROOT = path.join(__dirname, '..', 'test-server-root');
+
+export const getTestFilePath = (relativePath) => {
+  return path.join(TEST_SERVER_ROOT, relativePath);
+};

package/tests/utils/test-scenario.js

@@ -0,0 +1,29 @@
+import {writeFile, mkdir} from 'fs/promises';
+import path from 'path';
+
+export const prepareTestScenario = async (dir, scenario) => {
+  switch (scenario) {
+    case 'basic-server':
+      // Already has index.html, api/GET.js, etc.
+      break;
+    case 'wildcard-routes':
+      await write(dir, 'docs/.config.json', JSON.stringify({
+        customRoutes: { '/src/**': '../src/**' }
+      }));
+      break;
+    case 'middleware':
+      await write(dir, '.config.json', JSON.stringify({
+        middleware: { cors: {enabled: true} }
+      }));
+      break;
+    default:
+      // No special preparation needed
+  }
+};
+
+const write = async (root, rel, content = '') => {
+  const full = path.join(root, rel);
+  await mkdir(path.dirname(full), {recursive: true});
+  await writeFile(full, content);
+  return full;
+};

package/tests/utils/timing.js

@@ -0,0 +1 @@
+export const wait = ms => new Promise(r => setTimeout(r, ms));

package/dist/utils/ensure-build.js

@@ -1 +0,0 @@
-import{execSync}from"child_process";import fs from"fs";import path from"path";let hasBuilt=!1;export default function ensureBuild(){if(hasBuilt)return;const distIndex=path.join(process.cwd(),"dist/index.js");if(!fs.existsSync(distIndex))try{execSync("npm run build",{stdio:"pipe"}),console.log("✓ Build completed successfully")}catch(error){throw console.error("✗ Build failed:",error.message),error}hasBuilt=!0}

package/tests/test-utils.js

@@ -1,151 +0,0 @@
-import {Readable} from 'stream';
-import {mkdtemp, rm, writeFile, mkdir, cp} from 'fs/promises';
-import os from 'os';
-import path from 'path';
-import {fileURLToPath} from 'url';
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const TEST_SERVER_ROOT = path.join(__dirname, 'test-server-root');
-
-export const createMockReq = ({method = 'GET', url = '/', headers = {}, body = null, remoteAddress = '127.0.0.1'} = {}) => {
-  const stream = new Readable({read(){}});
-  stream.method = method;
-  stream.url = url;
-  stream.headers = headers;
-  stream.socket = {remoteAddress};
-  if(body !== null && body !== undefined){
-    const data = typeof body === 'string' || Buffer.isBuffer(body) ? body : JSON.stringify(body);
-    setImmediate(() => {
-      stream.emit('data', Buffer.from(data));
-      stream.emit('end');
-    });
-  } else {
-    setImmediate(() => stream.emit('end'));
-  }
-  return stream;
-};
-
-export const createMockRes = () => {
-  const headers = new Map();
-  let ended = false;
-  let statusCode = 200;
-  const chunks = [];
-  return {
-    get statusCode(){return statusCode;},
-    set statusCode(v){statusCode = v;},
-    setHeader: (k, v) => headers.set(k, v),
-    getHeader: (k) => headers.get(k),
-    writeHead: (code, hdrs = {}) => {
-      statusCode = code;
-      Object.entries(hdrs).forEach(([k, v]) => headers.set(k, v));
-    },
-    write: (chunk) => { if(chunk) chunks.push(Buffer.from(chunk)); return true; },
-    end: (chunk) => { if(chunk) chunks.push(Buffer.from(chunk)); ended = true; },
-    getHeaders: () => Object.fromEntries(headers),
-    getBody: () => Buffer.concat(chunks),
-    isEnded: () => ended
-  };
-};
-
-// Legacy function for backward compatibility - will be deprecated
-export const withTempDir = async (fn) => {
-  const dir = await mkdtemp(path.join(os.tmpdir(), 'kempo-tests-'));
-  try {
-    return await fn(dir);
-  } finally {
-    await rm(dir, {recursive: true, force: true});
-  }
-};
-
-// New function that uses the persistent test server root as a base
-export const withTestDir = async (fn, {subdir = null} = {}) => {
-  const tempDir = await mkdtemp(path.join(os.tmpdir(), 'kempo-tests-'));
-  try {
-    // Copy the test server root to the temporary directory
-    await cp(TEST_SERVER_ROOT, tempDir, {recursive: true});
-    let workingDir = tempDir;
-    
-    if (subdir) {
-      workingDir = path.join(tempDir, subdir);
-    }
-    
-    return await fn(workingDir);
-  } finally {
-    await rm(tempDir, {recursive: true, force: true});
-  }
-};
-
-// Helper to get the path to a file in the test server root
-export const getTestFilePath = (relativePath) => {
-  return path.join(TEST_SERVER_ROOT, relativePath);
-};
-
-// Helper to reset or prepare specific test scenarios
-export const prepareTestScenario = async (dir, scenario) => {
-  switch (scenario) {
-    case 'basic-server':
-      // Already has index.html, api/GET.js, etc.
-      break;
-    case 'wildcard-routes':
-      await write(dir, 'docs/.config.json', JSON.stringify({
-        customRoutes: { '/src/**': '../src/**' }
-      }));
-      break;
-    case 'middleware':
-      await write(dir, '.config.json', JSON.stringify({
-        middleware: { cors: {enabled: true} }
-      }));
-      break;
-    default:
-      // No special preparation needed
-  }
-};
-
-export const write = async (root, rel, content = '') => {
-  const full = path.join(root, rel);
-  await mkdir(path.dirname(full), {recursive: true});
-  await writeFile(full, content);
-  return full;
-};
-
-export const wait = ms => new Promise(r => setTimeout(r, ms));
-
-export const log = (..._args) => {};
-
-export const bigString = (size = 5000) => 'x'.repeat(size);
-
-export const randomPort = () => 1024 + Math.floor(Math.random() * 50000);
-
-export const httpGet = (url) => new Promise((resolve, reject) => {
-  import('http').then(({get}) => {
-    get(url, res => {
-      const chunks = [];
-      res.on('data', c => chunks.push(c));
-      res.on('end', () => resolve({res, body: Buffer.concat(chunks)}));
-    }).on('error', reject);
-  }).catch(reject);
-});
-
-export const startNode = async (args, options = {}) => {
-  const {spawn} = await import('child_process');
-  const child = spawn(process.execPath, args, {stdio: ['ignore', 'pipe', 'pipe'], ...options});
-  child.stdout.setEncoding('utf8');
-  child.stderr.setEncoding('utf8');
-  return child;
-};
-
-export const setEnv = (pairs, fn) => {
-  const prev = {};
-  Object.keys(pairs).forEach(k => { prev[k] = process.env[k]; process.env[k] = pairs[k]; });
-  const restore = () => { Object.keys(pairs).forEach(k => { if(prev[k] === undefined){ delete process.env[k]; } else { process.env[k] = prev[k]; } }); };
-  return fn().finally(restore);
-};
-
-export const toString = (buf) => Buffer.isBuffer(buf) ? buf.toString() : String(buf);
-
-export const gzipSize = async (buf) => {
-  const {gzip} = await import('zlib');
-  return new Promise((res, rej) => gzip(buf, (e, out) => e ? rej(e) : res(out.length)));
-};
-
-export const parseCookies = (setCookie) => Array.isArray(setCookie) ? setCookie : (setCookie ? [setCookie] : []);