blaizejs 0.2.2 → 0.2.3

package/dist/index.js

@@ -1,11 +1,17 @@
 /**
- * blaizejs v0.2.2
+ * blaizejs v0.2.3
  * A blazing-fast, TypeScript-first Node.js framework with HTTP/2 support, file-based routing, powerful middleware system, and end-to-end type safety for building modern APIs.
  * 
  * Copyright (c) 2025 BlaizeJS Contributors
  * @license MIT
  */
 
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
 
 // src/middleware/execute.ts
 function execute(middleware, ctx, next) {
@@ -107,6 +113,9 @@ function create2(name, version, setup, defaultOptions = {}) {
   };
 }
 
+// src/router/create.ts
+import { fileURLToPath } from "node:url";
+
 // src/config.ts
 var config = {};
 function setRuntimeConfig(newConfig) {
@@ -178,73 +187,75 @@ function getCallerFilePath() {
     if (!fileName) {
       throw new Error("Unable to determine caller file name");
     }
+    if (fileName.startsWith("file://")) {
+      return fileURLToPath(fileName);
+    }
     return fileName;
   } finally {
     Error.prepareStackTrace = originalPrepareStackTrace;
   }
 }
 function getRoutePath() {
-  console.log("getRoutePath called");
   const callerPath = getCallerFilePath();
   const routesDir = getRoutesDir();
   const parsedRoute = parseRoutePath(callerPath, routesDir);
-  console.log(`Parsed route path: ${parsedRoute.routePath} from file: ${callerPath}`);
+  console.log(`\u{1F50E} Parsed route path: ${parsedRoute.routePath} from file: ${callerPath}`);
   return parsedRoute.routePath;
 }
 var createGetRoute = (config2) => {
   validateMethodConfig("GET", config2);
-  const path5 = getRoutePath();
+  const path6 = getRoutePath();
   return {
     GET: config2,
-    path: path5
+    path: path6
   };
 };
 var createPostRoute = (config2) => {
   validateMethodConfig("POST", config2);
-  const path5 = getRoutePath();
+  const path6 = getRoutePath();
   return {
     POST: config2,
-    path: path5
+    path: path6
   };
 };
 var createPutRoute = (config2) => {
   validateMethodConfig("PUT", config2);
-  const path5 = getRoutePath();
+  const path6 = getRoutePath();
   return {
     PUT: config2,
-    path: path5
+    path: path6
   };
 };
 var createDeleteRoute = (config2) => {
   validateMethodConfig("DELETE", config2);
-  const path5 = getRoutePath();
+  const path6 = getRoutePath();
   return {
     DELETE: config2,
-    path: path5
+    path: path6
   };
 };
 var createPatchRoute = (config2) => {
   validateMethodConfig("PATCH", config2);
-  const path5 = getRoutePath();
+  const path6 = getRoutePath();
   return {
     PATCH: config2,
-    path: path5
+    path: path6
   };
 };
 var createHeadRoute = (config2) => {
   validateMethodConfig("HEAD", config2);
-  const path5 = getRoutePath();
+  const path6 = getRoutePath();
   return {
     HEAD: config2,
-    path: path5
+    path: path6
   };
 };
 var createOptionsRoute = (config2) => {
   validateMethodConfig("OPTIONS", config2);
-  const path5 = getRoutePath();
+  const path6 = getRoutePath();
   return {
     OPTIONS: config2,
-    path: path5
+    path: path6
   };
 };
 function validateMethodConfig(method, config2) {
@@ -389,7 +400,7 @@ function parseRequestUrl(req) {
   const fullUrl = `${protocol}://${host}${originalUrl.startsWith("/") ? "" : "/"}${originalUrl}`;
   try {
     const url = new URL(fullUrl);
-    const path5 = url.pathname;
+    const path6 = url.pathname;
     const query = {};
     url.searchParams.forEach((value, key) => {
       if (query[key] !== void 0) {
@@ -402,7 +413,7 @@ function parseRequestUrl(req) {
         query[key] = value;
       }
     });
-    return { path: path5, url, query };
+    return { path: path6, url, query };
   } catch (error) {
     console.warn(`Invalid URL: ${fullUrl}`, error);
     throw new ParseUrlError(`Invalid URL: ${fullUrl}`);
@@ -424,7 +435,7 @@ function getProtocol(req) {
   return encrypted ? "https" : "http";
 }
 async function createContext(req, res, options = {}) {
-  const { path: path5, url, query } = parseRequestUrl(req);
+  const { path: path6, url, query } = parseRequestUrl(req);
   const method = req.method || "GET";
   const isHttp2 = isHttp2Request(req);
   const protocol = getProtocol(req);
@@ -433,7 +444,7 @@ async function createContext(req, res, options = {}) {
   const responseState = { sent: false };
   const ctx = {
     request: createRequestObject(req, {
-      path: path5,
+      path: path6,
       url,
       query,
       params,
@@ -705,13 +716,13 @@ function setBodyError(ctx, type, message, error) {
   ctx.state._bodyError = { type, message, error };
 }
 async function readRequestBody(req) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     const chunks = [];
     req.on("data", (chunk) => {
       chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
     });
     req.on("end", () => {
-      resolve2(Buffer.concat(chunks).toString("utf8"));
+      resolve3(Buffer.concat(chunks).toString("utf8"));
     });
     req.on("error", (err) => {
       reject(err);
@@ -809,7 +820,7 @@ function createServerInstance(isHttp2, certOptions) {
   return http2.createSecureServer(http2ServerOptions);
 }
 function listenOnPort(server, port, host, isHttp2) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     server.listen(port, host, () => {
       const protocol = isHttp2 ? "https" : "http";
       const url = `${protocol}://${host}:${port}`;
@@ -826,7 +837,7 @@ function listenOnPort(server, port, host, isHttp2) {
 
 \u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}
 `);
-      resolve2();
+      resolve3();
     });
     server.on("error", (err) => {
       console.error("Server error:", err);
@@ -870,55 +881,128 @@ async function startServer(serverInstance, serverOptions) {
 }
 
 // src/server/stop.ts
+var isShuttingDown = false;
 async function stopServer(serverInstance, options = {}) {
   const server = serverInstance.server;
   const events = serverInstance.events;
+  if (isShuttingDown) {
+    console.log("\u26A0\uFE0F Shutdown already in progress, ignoring duplicate shutdown request");
+    return;
+  }
   if (!server) {
     return;
   }
-  const timeout = options.timeout || 3e4;
+  isShuttingDown = true;
+  const timeout = options.timeout || 5e3;
   try {
     if (options.onStopping) {
       await options.onStopping();
     }
     events.emit("stopping");
-    await serverInstance.pluginManager.onServerStop(serverInstance, server);
+    if (serverInstance.router && typeof serverInstance.router.close === "function") {
+      console.log("\u{1F50C} Closing router watchers...");
+      try {
+        await Promise.race([
+          serverInstance.router.close(),
+          new Promise(
+            (_, reject) => setTimeout(() => reject(new Error("Router close timeout")), 2e3)
+          )
+        ]);
+        console.log("\u2705 Router watchers closed");
+      } catch (error) {
+        console.error("\u274C Error closing router watchers:", error);
+      }
+    }
+    try {
+      await Promise.race([
+        serverInstance.pluginManager.onServerStop(serverInstance, server),
+        new Promise(
+          (_, reject) => setTimeout(() => reject(new Error("Plugin stop timeout")), 2e3)
+        )
+      ]);
+    } catch (error) {
+      console.error("\u274C Plugin stop timeout:", error);
+    }
+    const closePromise = new Promise((resolve3, reject) => {
+      server.close((err) => {
+        if (err) return reject(err);
+        resolve3();
+      });
+    });
     const timeoutPromise = new Promise((_, reject) => {
       setTimeout(() => {
-        reject(new Error("Server shutdown timed out waiting for requests to complete"));
+        reject(new Error("Server shutdown timeout"));
       }, timeout);
     });
-    const closePromise = new Promise((resolve2, reject) => {
-      server.close((err) => {
-        if (err) {
-          return reject(err);
-        }
-        resolve2();
-      });
-    });
     await Promise.race([closePromise, timeoutPromise]);
-    await serverInstance.pluginManager.terminatePlugins(serverInstance);
+    try {
+      await Promise.race([
+        serverInstance.pluginManager.terminatePlugins(serverInstance),
+        new Promise(
+          (_, reject) => setTimeout(() => reject(new Error("Plugin terminate timeout")), 1e3)
+        )
+      ]);
+    } catch (error) {
+      console.error("\u274C Plugin terminate timeout:", error);
+    }
     if (options.onStopped) {
       await options.onStopped();
     }
     events.emit("stopped");
     serverInstance.server = null;
+    console.log("\u2705 Graceful shutdown completed");
+    isShuttingDown = false;
   } catch (error) {
+    isShuttingDown = false;
+    console.error("\u26A0\uFE0F Shutdown error (forcing exit):", error);
+    if (server && typeof server.close === "function") {
+      server.close();
+    }
+    if (process.env.NODE_ENV === "development") {
+      console.log("\u{1F504} Forcing exit for development restart...");
+      process.exit(0);
+    }
     events.emit("error", error);
     throw error;
   }
 }
 function registerSignalHandlers(stopFn) {
-  const sigintHandler = () => stopFn().catch(console.error);
-  const sigtermHandler = () => stopFn().catch(console.error);
-  process.on("SIGINT", sigintHandler);
-  process.on("SIGTERM", sigtermHandler);
-  return {
-    unregister: () => {
-      process.removeListener("SIGINT", sigintHandler);
-      process.removeListener("SIGTERM", sigtermHandler);
-    }
-  };
+  const isDevelopment = process.env.NODE_ENV === "development";
+  if (isDevelopment) {
+    const sigintHandler = () => {
+      console.log("\u{1F4E4} SIGINT received, forcing exit for development restart...");
+      process.exit(0);
+    };
+    const sigtermHandler = () => {
+      console.log("\u{1F4E4} SIGTERM received, forcing exit for development restart...");
+      process.exit(0);
+    };
+    process.on("SIGINT", sigintHandler);
+    process.on("SIGTERM", sigtermHandler);
+    return {
+      unregister: () => {
+        process.removeListener("SIGINT", sigintHandler);
+        process.removeListener("SIGTERM", sigtermHandler);
+      }
+    };
+  } else {
+    const sigintHandler = () => {
+      console.log("\u{1F4E4} SIGINT received, starting graceful shutdown...");
+      stopFn().catch(console.error);
+    };
+    const sigtermHandler = () => {
+      console.log("\u{1F4E4} SIGTERM received, starting graceful shutdown...");
+      stopFn().catch(console.error);
+    };
+    process.on("SIGINT", sigintHandler);
+    process.on("SIGTERM", sigtermHandler);
+    return {
+      unregister: () => {
+        process.removeListener("SIGINT", sigintHandler);
+        process.removeListener("SIGTERM", sigtermHandler);
+      }
+    };
+  }
 }
 
 // src/server/validation.ts
@@ -1124,59 +1208,33 @@ function validatePlugin(plugin, options = {}) {
   }
 }
 
-// src/router/discovery/finder.ts
+// src/router/discovery/cache.ts
+import * as crypto from "node:crypto";
 import * as fs3 from "node:fs/promises";
+import { createRequire } from "node:module";
 import * as path3 from "node:path";
-async function findRouteFiles(routesDir, options = {}) {
-  const absoluteDir = path3.isAbsolute(routesDir) ? routesDir : path3.resolve(process.cwd(), routesDir);
-  console.log("Creating router with routes directory:", absoluteDir);
-  try {
-    const stats = await fs3.stat(absoluteDir);
-    if (!stats.isDirectory()) {
-      throw new Error(`Route directory is not a directory: ${absoluteDir}`);
-    }
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      throw new Error(`Route directory not found: ${absoluteDir}`);
-    }
-    throw error;
-  }
-  const routeFiles = [];
-  const ignore = options.ignore || ["node_modules", ".git"];
-  async function scanDirectory(dir) {
-    const entries = await fs3.readdir(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = path3.join(dir, entry.name);
-      if (entry.isDirectory() && ignore.includes(entry.name)) {
-        continue;
-      }
-      if (entry.isDirectory()) {
-        await scanDirectory(fullPath);
-      } else if (isRouteFile(entry.name)) {
-        routeFiles.push(fullPath);
-      }
-    }
-  }
-  await scanDirectory(absoluteDir);
-  return routeFiles;
-}
-function isRouteFile(filename) {
-  return !filename.startsWith("_") && (filename.endsWith(".ts") || filename.endsWith(".js"));
-}
 
 // src/router/discovery/loader.ts
 async function dynamicImport(filePath) {
-  return import(filePath);
+  const cacheBuster = `?t=${Date.now()}`;
+  const importPath = filePath + cacheBuster;
+  try {
+    const module = await import(importPath);
+    console.log(`\u2705 Successfully imported module`);
+    return module;
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.log(`\u26A0\uFE0F Error importing with cache buster, trying original path:`, errorMessage);
+    return import(filePath);
+  }
 }
 async function loadRouteModule(filePath, basePath) {
   try {
     const parsedRoute = parseRoutePath(filePath, basePath);
-    console.log("parsedRoute:", parsedRoute);
     const module = await dynamicImport(filePath);
-    console.log("Module exports:", Object.keys(module));
+    console.log("\u{1F4E6} Module exports:", Object.keys(module));
     const routes = [];
     if (module.default && typeof module.default === "object") {
-      console.log("Found default export:", module.default);
       const route = {
         ...module.default,
         path: parsedRoute.routePath
@@ -1189,7 +1247,6 @@ async function loadRouteModule(filePath, basePath) {
       }
       const potentialRoute = exportValue;
       if (isValidRoute(potentialRoute)) {
-        console.log(`Found named route export: ${exportName}`, potentialRoute);
         const route = {
           ...potentialRoute,
           // Use the route's own path if it has one, otherwise derive from file
@@ -1202,7 +1259,7 @@ async function loadRouteModule(filePath, basePath) {
       console.warn(`Route file ${filePath} does not export any valid route definitions`);
       return [];
     }
-    console.log(`Loaded ${routes.length} route(s) from ${filePath}`);
+    console.log(`\u2705 Successfully Loaded ${routes.length} route(s)`);
     return routes;
   } catch (error) {
     console.error(`Failed to load route module ${filePath}:`, error);
@@ -1220,25 +1277,222 @@ function isValidRoute(obj) {
   return hasHttpMethod;
 }
 
-// src/router/discovery/index.ts
-async function findRoutes(routesDir, options = {}) {
-  const routeFiles = await findRouteFiles(routesDir, {
-    ignore: options.ignore
-  });
-  const routes = [];
-  for (const filePath of routeFiles) {
-    const moduleRoutes = await loadRouteModule(filePath, routesDir);
-    if (moduleRoutes.length > 0) {
-      routes.push(...moduleRoutes);
-    }
+// src/router/discovery/cache.ts
+var fileRouteCache = /* @__PURE__ */ new Map();
+async function processChangedFile(filePath, routesDir, updateCache = true) {
+  const stat3 = await fs3.stat(filePath);
+  const lastModified = stat3.mtime.getTime();
+  const cachedEntry = fileRouteCache.get(filePath);
+  if (updateCache && cachedEntry && cachedEntry.timestamp === lastModified) {
+    return cachedEntry.routes;
+  }
+  invalidateModuleCache(filePath);
+  const routes = await loadRouteModule(filePath, routesDir);
+  if (updateCache) {
+    const hash = hashRoutes(routes);
+    fileRouteCache.set(filePath, {
+      routes,
+      timestamp: lastModified,
+      hash
+    });
   }
   return routes;
 }
+function hasRouteContentChanged(filePath, newRoutes) {
+  const cachedEntry = fileRouteCache.get(filePath);
+  if (!cachedEntry) {
+    return true;
+  }
+  const newHash = hashRoutes(newRoutes);
+  return cachedEntry.hash !== newHash;
+}
+function clearFileCache(filePath) {
+  if (filePath) {
+    fileRouteCache.delete(filePath);
+  } else {
+    fileRouteCache.clear();
+  }
+}
+function hashRoutes(routes) {
+  const routeData = routes.map((route) => ({
+    path: route.path,
+    methods: Object.keys(route).filter((key) => key !== "path").sort().map((method) => {
+      const methodDef = route[method];
+      const handlerString = methodDef?.handler ? methodDef.handler.toString() : null;
+      return {
+        method,
+        // Include handler function string for change detection
+        handler: handlerString,
+        // Include middleware if present
+        middleware: methodDef?.middleware ? methodDef.middleware.length : 0,
+        // Include schema structure (but not full serialization which can be unstable)
+        hasSchema: !!methodDef?.schema,
+        schemaKeys: methodDef?.schema ? Object.keys(methodDef.schema).sort() : []
+      };
+    })
+  }));
+  const dataString = JSON.stringify(routeData);
+  const hash = crypto.createHash("md5").update(dataString).digest("hex");
+  return hash;
+}
+function invalidateModuleCache(filePath) {
+  try {
+    const absolutePath = path3.resolve(filePath);
+    if (typeof __require !== "undefined") {
+      delete __require.cache[absolutePath];
+      try {
+        const resolvedPath = __require.resolve(absolutePath);
+        delete __require.cache[resolvedPath];
+      } catch (resolveError) {
+        const errorMessage = resolveError instanceof Error ? resolveError.message : String(resolveError);
+        console.log(`\u26A0\uFE0F Could not resolve path: ${errorMessage}`);
+      }
+    } else {
+      try {
+        const require2 = createRequire(import.meta.url);
+        delete require2.cache[absolutePath];
+        try {
+          const resolvedPath = require2.resolve(absolutePath);
+          delete require2.cache[resolvedPath];
+        } catch {
+          console.log(`\u26A0\uFE0F Could not resolve ESM path`);
+        }
+      } catch {
+        console.log(`\u26A0\uFE0F createRequire not available in pure ESM`);
+      }
+    }
+  } catch (error) {
+    console.log(`\u26A0\uFE0F Error during module cache invalidation for ${filePath}:`, error);
+  }
+}
 
-// src/router/discovery/watchers.ts
+// src/router/discovery/parallel.ts
+import * as os from "node:os";
+
+// src/router/discovery/finder.ts
+import * as fs4 from "node:fs/promises";
 import * as path4 from "node:path";
+async function findRouteFiles(routesDir, options = {}) {
+  const absoluteDir = path4.isAbsolute(routesDir) ? routesDir : path4.resolve(process.cwd(), routesDir);
+  console.log("Creating router with routes directory:", absoluteDir);
+  try {
+    const stats = await fs4.stat(absoluteDir);
+    if (!stats.isDirectory()) {
+      throw new Error(`Route directory is not a directory: ${absoluteDir}`);
+    }
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new Error(`Route directory not found: ${absoluteDir}`);
+    }
+    throw error;
+  }
+  const routeFiles = [];
+  const ignore = options.ignore || ["node_modules", ".git"];
+  async function scanDirectory(dir) {
+    const entries = await fs4.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path4.join(dir, entry.name);
+      if (entry.isDirectory() && ignore.includes(entry.name)) {
+        continue;
+      }
+      if (entry.isDirectory()) {
+        await scanDirectory(fullPath);
+      } else if (isRouteFile(entry.name)) {
+        routeFiles.push(fullPath);
+      }
+    }
+  }
+  await scanDirectory(absoluteDir);
+  return routeFiles;
+}
+function isRouteFile(filename) {
+  return !filename.startsWith("_") && (filename.endsWith(".ts") || filename.endsWith(".js"));
+}
+
+// src/router/discovery/parallel.ts
+async function processFilesInParallel(filePaths, processor, concurrency = Math.max(1, Math.floor(os.cpus().length / 2))) {
+  const chunks = chunkArray(filePaths, concurrency);
+  const results = [];
+  for (const chunk of chunks) {
+    const chunkResults = await Promise.allSettled(chunk.map((filePath) => processor(filePath)));
+    const successfulResults = chunkResults.filter((result) => result.status === "fulfilled").map((result) => result.value);
+    results.push(...successfulResults);
+  }
+  return results;
+}
+async function loadInitialRoutesParallel(routesDir) {
+  const files = await findRouteFiles(routesDir);
+  const routeArrays = await processFilesInParallel(
+    files,
+    (filePath) => processChangedFile(filePath, routesDir)
+  );
+  return routeArrays.flat();
+}
+function chunkArray(array, chunkSize) {
+  const chunks = [];
+  for (let i = 0; i < array.length; i += chunkSize) {
+    chunks.push(array.slice(i, i + chunkSize));
+  }
+  return chunks;
+}
+
+// src/router/discovery/profiler.ts
+var profilerState = {
+  fileChanges: 0,
+  totalReloadTime: 0,
+  averageReloadTime: 0,
+  slowReloads: []
+};
+function trackReloadPerformance(filePath, startTime) {
+  const duration = Date.now() - startTime;
+  profilerState.fileChanges++;
+  profilerState.totalReloadTime += duration;
+  profilerState.averageReloadTime = profilerState.totalReloadTime / profilerState.fileChanges;
+  if (duration > 100) {
+    profilerState.slowReloads.push({ file: filePath, time: duration });
+    if (profilerState.slowReloads.length > 10) {
+      profilerState.slowReloads.shift();
+    }
+  }
+  if (process.env.NODE_ENV === "development") {
+    const emoji = duration < 50 ? "\u26A1" : duration < 100 ? "\u{1F504}" : "\u{1F40C}";
+    console.log(`${emoji} Route reload: ${filePath} (${duration}ms)`);
+  }
+}
+function withPerformanceTracking(fn, filePath) {
+  console.log(`Tracking performance for: ${filePath}`);
+  return async (...args) => {
+    const startTime = Date.now();
+    try {
+      const result = await fn(...args);
+      trackReloadPerformance(filePath, startTime);
+      return result;
+    } catch (error) {
+      trackReloadPerformance(filePath, startTime);
+      throw error;
+    }
+  };
+}
+
+// src/router/discovery/watchers.ts
+import * as path5 from "node:path";
 import { watch } from "chokidar";
 function watchRoutes(routesDir, options = {}) {
+  const debounceMs = options.debounceMs || 16;
+  const debouncedCallbacks = /* @__PURE__ */ new Map();
+  function createDebouncedCallback(fn, filePath) {
+    return (...args) => {
+      const existingTimeout = debouncedCallbacks.get(filePath);
+      if (existingTimeout) {
+        clearTimeout(existingTimeout);
+      }
+      const timeoutId = setTimeout(() => {
+        fn(...args);
+        debouncedCallbacks.delete(filePath);
+      }, debounceMs);
+      debouncedCallbacks.set(filePath, timeoutId);
+    };
+  }
   const routesByPath = /* @__PURE__ */ new Map();
   async function loadInitialRoutes() {
     try {
@@ -1254,28 +1508,34 @@ function watchRoutes(routesDir, options = {}) {
   }
   async function loadAndNotify(filePath) {
     try {
-      const routes = await loadRouteModule(filePath, routesDir);
-      if (!routes || routes.length === 0) {
+      const existingRoutes = routesByPath.get(filePath);
+      const newRoutes = await processChangedFile(filePath, routesDir, false);
+      if (!newRoutes || newRoutes.length === 0) {
         return;
       }
-      const existingRoutes = routesByPath.get(filePath);
+      if (existingRoutes && !hasRouteContentChanged(filePath, newRoutes)) {
+        return;
+      }
+      await processChangedFile(filePath, routesDir, true);
+      const normalizedPath = path5.normalize(filePath);
       if (existingRoutes) {
-        routesByPath.set(filePath, routes);
+        routesByPath.set(filePath, newRoutes);
         if (options.onRouteChanged) {
-          options.onRouteChanged(routes);
+          options.onRouteChanged(normalizedPath, newRoutes);
         }
       } else {
-        routesByPath.set(filePath, routes);
+        routesByPath.set(filePath, newRoutes);
         if (options.onRouteAdded) {
-          options.onRouteAdded(routes);
+          options.onRouteAdded(normalizedPath, newRoutes);
         }
       }
     } catch (error) {
+      console.log(`\u26A0\uFE0F Error processing file ${filePath}:`, error);
       handleError(error);
     }
   }
   function handleRemoved(filePath) {
-    const normalizedPath = path4.normalize(filePath);
+    const normalizedPath = path5.normalize(filePath);
     const routes = routesByPath.get(normalizedPath);
     if (routes && routes.length > 0 && options.onRouteRemoved) {
       options.onRouteRemoved(normalizedPath, routes);
@@ -1286,33 +1546,53 @@ function watchRoutes(routesDir, options = {}) {
     if (options.onError && error instanceof Error) {
       options.onError(error);
     } else {
-      console.error("Route watcher error:", error);
+      console.error("\u26A0\uFE0F Route watcher error:", error);
     }
   }
   const watcher = watch(routesDir, {
+    // Much faster response times
+    awaitWriteFinish: {
+      stabilityThreshold: 50,
+      // Reduced from 300ms
+      pollInterval: 10
+      // Reduced from 100ms
+    },
+    // Performance optimizations
+    usePolling: false,
+    atomic: true,
+    followSymlinks: false,
+    depth: 10,
+    // More aggressive ignoring
     ignored: [
       /(^|[/\\])\../,
-      // Ignore dot files
       /node_modules/,
+      /\.git/,
+      /\.DS_Store/,
+      /Thumbs\.db/,
+      /\.(test|spec)\.(ts|js)$/,
+      /\.d\.ts$/,
+      /\.map$/,
+      /~$/,
       ...options.ignore || []
-    ],
-    persistent: true,
-    ignoreInitial: false,
-    awaitWriteFinish: {
-      stabilityThreshold: 300,
-      pollInterval: 100
-    }
+    ]
   });
-  watcher.on("add", loadAndNotify).on("change", loadAndNotify).on("unlink", handleRemoved).on("error", handleError);
+  watcher.on("add", (filePath) => {
+    const debouncedLoad = createDebouncedCallback(loadAndNotify, filePath);
+    debouncedLoad(filePath);
+  }).on("change", (filePath) => {
+    const debouncedLoad = createDebouncedCallback(loadAndNotify, filePath);
+    debouncedLoad(filePath);
+  }).on("unlink", (filePath) => {
+    const debouncedRemove = createDebouncedCallback(handleRemoved, filePath);
+    debouncedRemove(filePath);
+  }).on("error", handleError);
   loadInitialRoutes().catch(handleError);
   return {
-    /**
-     * Close the watcher
-     */
-    close: () => watcher.close(),
-    /**
-     * Get all currently loaded routes (flattened)
-     */
+    close: () => {
+      debouncedCallbacks.forEach((timeout) => clearTimeout(timeout));
+      debouncedCallbacks.clear();
+      return watcher.close();
+    },
     getRoutes: () => {
       const allRoutes = [];
       for (const routes of routesByPath.values()) {
@@ -1320,9 +1600,6 @@ function watchRoutes(routesDir, options = {}) {
       }
       return allRoutes;
     },
-    /**
-     * Get routes organized by file path
-     */
     getRoutesByFile: () => new Map(routesByPath)
   };
 }
@@ -1533,8 +1810,8 @@ async function executeHandler(ctx, routeOptions, params) {
 }
 
 // src/router/matching/params.ts
-function extractParams(path5, pattern, paramNames) {
-  const match = pattern.exec(path5);
+function extractParams(path6, pattern, paramNames) {
+  const match = pattern.exec(path6);
   if (!match) {
     return {};
   }
@@ -1544,15 +1821,15 @@ function extractParams(path5, pattern, paramNames) {
   }
   return params;
 }
-function compilePathPattern(path5) {
+function compilePathPattern(path6) {
   const paramNames = [];
-  if (path5 === "/") {
+  if (path6 === "/") {
     return {
       pattern: /^\/$/,
       paramNames: []
     };
   }
-  let patternString = path5.replace(/([.+*?^$(){}|\\])/g, "\\$1");
+  let patternString = path6.replace(/([.+*?^$(){}|\\])/g, "\\$1");
   patternString = patternString.replace(/\/:([^/]+)/g, (_, paramName) => {
     paramNames.push(paramName);
     return "/([^/]+)";
@@ -1575,10 +1852,10 @@ function createMatcher() {
     /**
      * Add a route to the matcher
      */
-    add(path5, method, routeOptions) {
-      const { pattern, paramNames } = compilePathPattern(path5);
+    add(path6, method, routeOptions) {
+      const { pattern, paramNames } = compilePathPattern(path6);
       const newRoute = {
-        path: path5,
+        path: path6,
         method,
         pattern,
         paramNames,
@@ -1591,17 +1868,33 @@ function createMatcher() {
         routes.splice(insertIndex, 0, newRoute);
       }
     },
+    /**
+     * Remove a route from the matcher by path
+     */
+    remove(path6) {
+      for (let i = routes.length - 1; i >= 0; i--) {
+        if (routes[i].path === path6) {
+          routes.splice(i, 1);
+        }
+      }
+    },
+    /**
+     * Clear all routes from the matcher
+     */
+    clear() {
+      routes.length = 0;
+    },
     /**
      * Match a URL path to a route
      */
-    match(path5, method) {
-      const pathname = path5.split("?")[0];
+    match(path6, method) {
+      const pathname = path6.split("?")[0];
       if (!pathname) return null;
       for (const route of routes) {
         if (route.method !== method) continue;
         const match = route.pattern.exec(pathname);
         if (match) {
-          const params = extractParams(path5, route.pattern, route.paramNames);
+          const params = extractParams(path6, route.pattern, route.paramNames);
           return {
             route: route.routeOptions,
             params
@@ -1609,14 +1902,14 @@ function createMatcher() {
         }
       }
       const matchingPath = routes.find(
-        (route) => route.method !== method && route.pattern.test(path5)
+        (route) => route.method !== method && route.pattern.test(path6)
       );
       if (matchingPath) {
         return {
           route: null,
           params: {},
           methodNotAllowed: true,
-          allowedMethods: routes.filter((route) => route.pattern.test(path5)).map((route) => route.method)
+          allowedMethods: routes.filter((route) => route.pattern.test(path6)).map((route) => route.method)
         };
       }
       return null;
@@ -1633,16 +1926,93 @@ function createMatcher() {
     /**
      * Find routes matching a specific path
      */
-    findRoutes(path5) {
-      return routes.filter((route) => route.pattern.test(path5)).map((route) => ({
+    findRoutes(path6) {
+      return routes.filter((route) => route.pattern.test(path6)).map((route) => ({
         path: route.path,
         method: route.method,
-        params: extractParams(path5, route.pattern, route.paramNames)
+        params: extractParams(path6, route.pattern, route.paramNames)
       }));
     }
   };
 }
 
+// src/router/registry/fast-registry.ts
+function createRouteRegistry() {
+  return {
+    routesByPath: /* @__PURE__ */ new Map(),
+    routesByFile: /* @__PURE__ */ new Map(),
+    pathToFile: /* @__PURE__ */ new Map()
+  };
+}
+function updateRoutesFromFile(registry, filePath, newRoutes) {
+  console.log(`Updating routes from file: ${filePath}`);
+  const oldPaths = registry.routesByFile.get(filePath) || /* @__PURE__ */ new Set();
+  const newPaths = new Set(newRoutes.map((r) => r.path));
+  const added = newRoutes.filter((r) => !oldPaths.has(r.path));
+  const removed = Array.from(oldPaths).filter((p) => !newPaths.has(p));
+  const potentiallyChanged = newRoutes.filter((r) => oldPaths.has(r.path));
+  const changed = potentiallyChanged.filter((route) => {
+    const existingRoute = registry.routesByPath.get(route.path);
+    return !existingRoute || !routesEqual(existingRoute, route);
+  });
+  applyRouteUpdates(registry, filePath, { added, removed, changed });
+  return { added, removed, changed };
+}
+function getAllRoutesFromRegistry(registry) {
+  return Array.from(registry.routesByPath.values());
+}
+function applyRouteUpdates(registry, filePath, updates) {
+  const { added, removed, changed } = updates;
+  removed.forEach((path6) => {
+    registry.routesByPath.delete(path6);
+    registry.pathToFile.delete(path6);
+  });
+  [...added, ...changed].forEach((route) => {
+    registry.routesByPath.set(route.path, route);
+    registry.pathToFile.set(route.path, filePath);
+  });
+  const allPathsForFile = /* @__PURE__ */ new Set([
+    ...added.map((r) => r.path),
+    ...changed.map((r) => r.path),
+    ...Array.from(registry.routesByFile.get(filePath) || []).filter((p) => !removed.includes(p))
+  ]);
+  if (allPathsForFile.size > 0) {
+    registry.routesByFile.set(filePath, allPathsForFile);
+  } else {
+    registry.routesByFile.delete(filePath);
+  }
+}
+function routesEqual(route1, route2) {
+  if (route1.path !== route2.path) return false;
+  const methods1 = Object.keys(route1).filter((k) => k !== "path").sort();
+  const methods2 = Object.keys(route2).filter((k) => k !== "path").sort();
+  if (methods1.length !== methods2.length) return false;
+  return methods1.every((method) => {
+    const handler1 = route1[method];
+    const handler2 = route2[method];
+    return typeof handler1 === typeof handler2;
+  });
+}
+
+// src/router/utils/matching-helpers.ts
+function addRouteToMatcher(route, matcher) {
+  Object.entries(route).forEach(([method, methodOptions]) => {
+    if (method === "path" || !methodOptions) return;
+    matcher.add(route.path, method, methodOptions);
+  });
+}
+function removeRouteFromMatcher(path6, matcher) {
+  if ("remove" in matcher && typeof matcher.remove === "function") {
+    matcher.remove(path6);
+  } else {
+    console.warn("Matcher does not support selective removal, consider adding remove() method");
+  }
+}
+function updateRouteInMatcher(route, matcher) {
+  removeRouteFromMatcher(route.path, matcher);
+  addRouteToMatcher(route, matcher);
+}
+
 // src/router/router.ts
 var DEFAULT_ROUTER_OPTIONS = {
   routesDir: "./routes",
@@ -1657,46 +2027,55 @@ function createRouter(options) {
   if (options.basePath && !options.basePath.startsWith("/")) {
     console.warn("Base path does nothing");
   }
-  const routes = [];
+  const registry = createRouteRegistry();
   const matcher = createMatcher();
   let initialized = false;
   let initializationPromise = null;
   let _watchers = null;
-  const routeSources = /* @__PURE__ */ new Map();
   const routeDirectories = /* @__PURE__ */ new Set([routerOptions.routesDir]);
-  function addRouteWithSource(route, source) {
-    const existingSources = routeSources.get(route.path) || [];
-    if (existingSources.includes(source)) {
-      console.warn(`Skipping duplicate route: ${route.path} from ${source}`);
-      return;
-    }
-    if (existingSources.length > 0) {
-      const conflictError = new Error(
-        `Route conflict for path "${route.path}": already defined in ${existingSources.join(", ")}, now being added from ${source}`
-      );
-      console.error(conflictError.message);
-      throw conflictError;
+  function applyMatcherChanges(changes) {
+    console.log("\n\u{1F527} APPLYING MATCHER CHANGES:");
+    console.log(`  Adding ${changes.added.length} routes`);
+    console.log(`  Removing ${changes.removed.length} routes`);
+    console.log(`  Updating ${changes.changed.length} routes`);
+    changes.removed.forEach((routePath) => {
+      console.log(`    \u2796 Removing: ${routePath}`);
+      removeRouteFromMatcher(routePath, matcher);
+    });
+    changes.added.forEach((route) => {
+      const methods = Object.keys(route).filter((key) => key !== "path");
+      console.log(`    \u2795 Adding: ${route.path} [${methods.join(", ")}]`);
+      addRouteToMatcher(route, matcher);
+    });
+    changes.changed.forEach((route) => {
+      const methods = Object.keys(route).filter((key) => key !== "path");
+      console.log(`    \u{1F504} Updating: ${route.path} [${methods.join(", ")}]`);
+      updateRouteInMatcher(route, matcher);
+    });
+    console.log("\u2705 Matcher changes applied\n");
+  }
+  function addRoutesWithSource(routes, source) {
+    try {
+      const changes = updateRoutesFromFile(registry, source, routes);
+      applyMatcherChanges(changes);
+      return changes;
+    } catch (error) {
+      console.error(`\u26A0\uFE0F Route conflicts from ${source}:`, error);
+      throw error;
     }
-    routeSources.set(route.path, [...existingSources, source]);
-    addRouteInternal(route);
   }
   async function loadRoutesFromDirectory(directory, source, prefix) {
     try {
-      const discoveredRoutes = await findRoutes(directory, {
-        basePath: routerOptions.basePath
-      });
-      for (const route of discoveredRoutes) {
-        const finalRoute = prefix ? {
-          ...route,
-          path: `${prefix}${route.path}`
-        } : route;
-        addRouteWithSource(finalRoute, source);
-      }
+      const discoveredRoutes = await loadInitialRoutesParallel(directory);
+      const finalRoutes = discoveredRoutes.map(
+        (route) => prefix ? { ...route, path: `${prefix}${route.path}` } : route
+      );
+      const changes = addRoutesWithSource(finalRoutes, source);
       console.log(
-        `Loaded ${discoveredRoutes.length} routes from ${source}${prefix ? ` with prefix ${prefix}` : ""}`
+        `Loaded ${discoveredRoutes.length} routes from ${source}${prefix ? ` with prefix ${prefix}` : ""} (${changes.added.length} added, ${changes.changed.length} changed, ${changes.removed.length} removed)`
       );
     } catch (error) {
-      console.error(`Failed to load routes from ${source}:`, error);
+      console.error(`\u26A0\uFE0F Failed to load routes from ${source}:`, error);
       throw error;
     }
   }
@@ -1706,105 +2085,126 @@ function createRouter(options) {
     }
     initializationPromise = (async () => {
       try {
-        for (const directory of routeDirectories) {
-          await loadRoutesFromDirectory(directory, directory);
-        }
+        await Promise.all(
+          Array.from(routeDirectories).map(
+            (directory) => loadRoutesFromDirectory(directory, directory)
+          )
+        );
         if (routerOptions.watchMode) {
-          setupWatcherForAllDirectories();
+          setupOptimizedWatching();
         }
         initialized = true;
       } catch (error) {
-        console.error("Failed to initialize router:", error);
+        console.error("\u26A0\uFE0F Failed to initialize router:", error);
         throw error;
       }
     })();
     return initializationPromise;
   }
-  function addRouteInternal(route) {
-    routes.push(route);
-    Object.entries(route).forEach(([method, methodOptions]) => {
-      if (method === "path" || !methodOptions) return;
-      matcher.add(route.path, method, methodOptions);
-    });
-  }
-  function createWatcherCallbacks(directory, source, prefix) {
-    return {
-      onRouteAdded: (addedRoutes) => {
-        console.log(
-          `${addedRoutes.length} route(s) added from ${directory}:`,
-          addedRoutes.map((r) => r.path)
-        );
-        addedRoutes.forEach((route) => {
-          const finalRoute = prefix ? { ...route, path: `${prefix}${route.path}` } : route;
-          addRouteWithSource(finalRoute, source);
-        });
-      },
-      onRouteChanged: (changedRoutes) => {
-        console.log(
-          `${changedRoutes.length} route(s) changed in ${directory}:`,
-          changedRoutes.map((r) => r.path)
-        );
-        changedRoutes.forEach((route) => {
-          const finalPath = prefix ? `${prefix}${route.path}` : route.path;
-          const index = routes.findIndex((r) => r.path === finalPath);
-          if (index >= 0) {
-            routes.splice(index, 1);
-            const sources = routeSources.get(finalPath) || [];
-            const filteredSources = sources.filter((s) => s !== source);
-            if (filteredSources.length > 0) {
-              routeSources.set(finalPath, filteredSources);
-            } else {
-              routeSources.delete(finalPath);
+  function setupOptimizedWatching() {
+    if (!_watchers) {
+      _watchers = /* @__PURE__ */ new Map();
+    }
+    for (const directory of routeDirectories) {
+      if (!_watchers.has(directory)) {
+        const watcher = watchRoutes(directory, {
+          debounceMs: 16,
+          // ~60fps debouncing
+          ignore: ["node_modules", ".git"],
+          onRouteAdded: (filepath, addedRoutes) => {
+            try {
+              const changes = updateRoutesFromFile(registry, filepath, addedRoutes);
+              applyMatcherChanges(changes);
+            } catch (error) {
+              console.error(`Error adding routes from ${directory}:`, error);
+            }
+          },
+          onRouteChanged: withPerformanceTracking(
+            async (filepath, changedRoutes) => {
+              try {
+                console.log(`Processing changes for ${filepath}`);
+                const changes = updateRoutesFromFile(registry, filepath, changedRoutes);
+                console.log(
+                  `Changes detected: ${changes.added.length} added, ${changes.changed.length} changed, ${changes.removed.length} removed`
+                );
+                applyMatcherChanges(changes);
+                console.log(
+                  `Route changes applied: ${changes.added.length} added, ${changes.changed.length} changed, ${changes.removed.length} removed`
+                );
+              } catch (error) {
+                console.error(`\u26A0\uFE0F Error updating routes from ${directory}:`, error);
+              }
+            },
+            directory
+          ),
+          onRouteRemoved: (filePath, removedRoutes) => {
+            console.log(`File removed: ${filePath} with ${removedRoutes.length} routes`);
+            try {
+              removedRoutes.forEach((route) => {
+                removeRouteFromMatcher(route.path, matcher);
+              });
+              clearFileCache(filePath);
+            } catch (error) {
+              console.error(`\u26A0\uFE0F Error removing routes from ${filePath}:`, error);
             }
+          },
+          onError: (error) => {
+            console.error(`\u26A0\uFE0F Route watcher error for ${directory}:`, error);
           }
-          const finalRoute = prefix ? { ...route, path: finalPath } : route;
-          addRouteWithSource(finalRoute, source);
         });
+        _watchers.set(directory, watcher);
+      }
+    }
+  }
+  function setupWatcherForNewDirectory(directory, prefix) {
+    if (!_watchers) {
+      _watchers = /* @__PURE__ */ new Map();
+    }
+    const watcher = watchRoutes(directory, {
+      debounceMs: 16,
+      ignore: ["node_modules", ".git"],
+      onRouteAdded: (filePath, addedRoutes) => {
+        try {
+          const finalRoutes = addedRoutes.map(
+            (route) => prefix ? { ...route, path: `${prefix}${route.path}` } : route
+          );
+          const changes = updateRoutesFromFile(registry, filePath, finalRoutes);
+          applyMatcherChanges(changes);
+        } catch (error) {
+          console.error(`\u26A0\uFE0F Error adding routes from ${directory}:`, error);
+        }
       },
+      onRouteChanged: withPerformanceTracking(async (filePath, changedRoutes) => {
+        try {
+          const finalRoutes = changedRoutes.map(
+            (route) => prefix ? { ...route, path: `${prefix}${route.path}` } : route
+          );
+          const changes = updateRoutesFromFile(registry, filePath, finalRoutes);
+          applyMatcherChanges(changes);
+        } catch (error) {
+          console.error(`\u26A0\uFE0F Error updating routes from ${directory}:`, error);
+        }
+      }, directory),
       onRouteRemoved: (filePath, removedRoutes) => {
-        console.log(
-          `File removed from ${directory}: ${filePath} with ${removedRoutes.length} route(s):`,
-          removedRoutes.map((r) => r.path)
-        );
-        removedRoutes.forEach((route) => {
-          const finalPath = prefix ? `${prefix}${route.path}` : route.path;
-          const index = routes.findIndex((r) => r.path === finalPath);
-          if (index >= 0) {
-            routes.splice(index, 1);
-          }
-          const sources = routeSources.get(finalPath) || [];
-          const filteredSources = sources.filter((s) => s !== source);
-          if (filteredSources.length > 0) {
-            routeSources.set(finalPath, filteredSources);
-          } else {
-            routeSources.delete(finalPath);
-          }
-        });
+        try {
+          removedRoutes.forEach((route) => {
+            const finalPath = prefix ? `${prefix}${route.path}` : route.path;
+            removeRouteFromMatcher(finalPath, matcher);
+          });
+          clearFileCache(filePath);
+        } catch (error) {
+          console.error(`Error removing routes from ${filePath}:`, error);
+        }
       },
       onError: (error) => {
-        console.error(`Route watcher error for ${directory}:`, error);
+        console.error(`\u26A0\uFE0F Route watcher error for ${directory}:`, error);
       }
-    };
-  }
-  function setupWatcherForDirectory(directory, source, prefix) {
-    const callbacks = createWatcherCallbacks(directory, source, prefix);
-    const watcher = watchRoutes(directory, {
-      ignore: ["node_modules", ".git"],
-      ...callbacks
     });
-    if (!_watchers) {
-      _watchers = /* @__PURE__ */ new Map();
-    }
     _watchers.set(directory, watcher);
     return watcher;
   }
-  function setupWatcherForAllDirectories() {
-    for (const directory of routeDirectories) {
-      setupWatcherForDirectory(directory, directory);
-    }
-  }
   initialize().catch((error) => {
-    console.error("Failed to initialize router on creation:", error);
+    console.error("\u26A0\uFE0F Failed to initialize router on creation:", error);
   });
   return {
     /**
@@ -1812,17 +2212,23 @@ function createRouter(options) {
      */
     async handleRequest(ctx) {
       if (!initialized) {
+        console.log("\u{1F504} Router not initialized, initializing...");
         await initialize();
       }
-      const { method, path: path5 } = ctx.request;
-      const match = matcher.match(path5, method);
+      const { method, path: path6 } = ctx.request;
+      console.log(`
+\u{1F4E5} Handling request: ${method} ${path6}`);
+      const match = matcher.match(path6, method);
       if (!match) {
+        console.log(`\u274C No match found for: ${method} ${path6}`);
         ctx.response.status(404).json({ error: "Not Found" });
         return;
       }
+      console.log(`\u2705 Route matched: ${method} ${path6}`);
+      console.log(`   Params: ${JSON.stringify(match.params)}`);
       if (match.methodNotAllowed) {
         ctx.response.status(405).json({
-          error: "Method Not Allowed",
+          error: "\u274C Method Not Allowed",
           allowed: match.allowedMethods
         });
         if (match.allowedMethods && match.allowedMethods.length > 0) {
@@ -1841,19 +2247,28 @@ function createRouter(options) {
       }
     },
     /**
-     * Get all registered routes
+     * Get all registered routes (using optimized registry)
      */
     getRoutes() {
-      return [...routes];
+      return getAllRoutesFromRegistry(registry);
     },
     /**
      * Add a route programmatically
      */
     addRoute(route) {
-      addRouteInternal(route);
+      const changes = updateRoutesFromFile(registry, "programmatic", [route]);
+      applyMatcherChanges(changes);
     },
     /**
-     * Add a route directory (for plugins)
+     * Add multiple routes programmatically with batch processing
+     */
+    addRoutes(routes) {
+      const changes = updateRoutesFromFile(registry, "programmatic", routes);
+      applyMatcherChanges(changes);
+      return changes;
+    },
+    /**
+     * Add a route directory (for plugins) with optimized loading
      */
     async addRouteDirectory(directory, options2 = {}) {
       if (routeDirectories.has(directory)) {
@@ -1864,21 +2279,27 @@ function createRouter(options) {
       if (initialized) {
         await loadRoutesFromDirectory(directory, directory, options2.prefix);
         if (routerOptions.watchMode) {
-          setupWatcherForDirectory(directory, directory, options2.prefix);
+          setupWatcherForNewDirectory(directory, options2.prefix);
         }
       }
     },
     /**
-     * Get route conflicts
+     * Get route conflicts (using registry)
      */
     getRouteConflicts() {
       const conflicts = [];
-      for (const [path5, sources] of routeSources.entries()) {
-        if (sources.length > 1) {
-          conflicts.push({ path: path5, sources });
+      return conflicts;
+    },
+    /**
+     * Close watchers and cleanup (useful for testing)
+     */
+    async close() {
+      if (_watchers) {
+        for (const watcher of _watchers.values()) {
+          await watcher.close();
         }
+        _watchers.clear();
       }
-      return conflicts;
     }
   };
 }