blaizejs 0.2.2 → 0.3.0

package/dist/index.js

@@ -1,11 +1,26 @@
 /**
- * blaizejs v0.2.2
+ * blaizejs v0.3.0
  * 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
  */
 
+import {
+  InternalServerError
+} from "./chunk-QQCQRHXJ.js";
+import {
+  ValidationError
+} from "./chunk-SRD3AB6T.js";
+import {
+  BlaizeError,
+  ErrorSeverity,
+  ErrorType,
+  __require,
+  generateCorrelationId,
+  getCurrentCorrelationId,
+  isBodyParseError
+} from "./chunk-TCPQMZ23.js";
 
 // src/middleware/execute.ts
 function execute(middleware, ctx, next) {
@@ -107,6 +122,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 +196,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) {
@@ -380,8 +400,474 @@ function runWithContext(context, callback) {
   return contextStorage.run(context, callback);
 }
 
+// src/upload/multipart-parser.ts
+import { randomUUID } from "node:crypto";
+import { createWriteStream } from "node:fs";
+import { tmpdir } from "node:os";
+import { join as join2 } from "node:path";
+import { Readable } from "node:stream";
+
+// src/upload/utils.ts
+var BOUNDARY_REGEX = /boundary=([^;]+)/i;
+var CONTENT_DISPOSITION_REGEX = /Content-Disposition:\s*form-data;\s*name="([^"]+)"(?:;[\s\r\n]*filename="([^"]*)")?/i;
+var CONTENT_TYPE_REGEX = /Content-Type:\s*([^\r\n]+)/i;
+var MULTIPART_REGEX = /multipart\/form-data/i;
+function extractBoundary(contentType) {
+  const match = contentType.match(BOUNDARY_REGEX);
+  if (!match || !match[1]) return null;
+  let boundary = match[1].trim();
+  if (boundary.startsWith('"') && boundary.endsWith('"')) {
+    boundary = boundary.slice(1, -1);
+  }
+  return boundary || null;
+}
+function parseContentDisposition(headers) {
+  const match = headers.match(CONTENT_DISPOSITION_REGEX);
+  if (!match || !match[1]) return null;
+  return {
+    name: match[1],
+    filename: match[2] !== void 0 ? match[2] : void 0
+  };
+}
+function parseContentType(headers) {
+  const match = headers.match(CONTENT_TYPE_REGEX);
+  return match && match[1]?.trim() ? match[1].trim() : "application/octet-stream";
+}
+function isMultipartContent(contentType) {
+  return MULTIPART_REGEX.test(contentType);
+}
+
+// src/upload/multipart-parser.ts
+var DEFAULT_OPTIONS = {
+  maxFileSize: 10 * 1024 * 1024,
+  // 10MB
+  maxFiles: 10,
+  maxFieldSize: 1 * 1024 * 1024,
+  // 1MB
+  allowedMimeTypes: [],
+  allowedExtensions: [],
+  strategy: "stream",
+  tempDir: tmpdir(),
+  computeHash: false
+};
+function createParserState(boundary, options = {}) {
+  return {
+    boundary: Buffer.from(`--${boundary}`),
+    options: { ...DEFAULT_OPTIONS, ...options },
+    fields: /* @__PURE__ */ new Map(),
+    files: /* @__PURE__ */ new Map(),
+    buffer: Buffer.alloc(0),
+    stage: "boundary",
+    currentHeaders: "",
+    currentField: null,
+    currentFilename: void 0,
+    currentMimetype: "application/octet-stream",
+    currentContentLength: 0,
+    fileCount: 0,
+    fieldCount: 0,
+    currentBufferChunks: [],
+    currentStream: null,
+    currentTempPath: null,
+    currentWriteStream: null,
+    streamController: null,
+    cleanupTasks: [],
+    // Track validation state
+    hasFoundValidBoundary: false,
+    hasProcessedAnyPart: false,
+    isFinished: false
+  };
+}
+async function processChunk(state, chunk) {
+  const newBuffer = Buffer.concat([state.buffer, chunk]);
+  let currentState = { ...state, buffer: newBuffer };
+  while (currentState.buffer.length > 0 && !currentState.isFinished) {
+    const nextState = await processCurrentStage(currentState);
+    if (nextState === currentState) break;
+    currentState = nextState;
+  }
+  return currentState;
+}
+async function processCurrentStage(state) {
+  switch (state.stage) {
+    case "boundary":
+      return processBoundary(state);
+    case "headers":
+      return processHeaders(state);
+    case "content":
+      return processContent(state);
+    default: {
+      const { InternalServerError: InternalServerError2 } = await import("./internal-server-error-CVRDTBLL.js");
+      throw new InternalServerError2(`Invalid parser stage`, {
+        operation: state.stage
+      });
+    }
+  }
+}
+function processBoundary(state) {
+  const boundaryIndex = state.buffer.indexOf(state.boundary);
+  if (boundaryIndex === -1) return state;
+  const hasFoundValidBoundary = true;
+  let buffer = state.buffer.subarray(boundaryIndex + state.boundary.length);
+  if (buffer.length >= 2 && buffer.subarray(0, 2).equals(Buffer.from("--"))) {
+    return {
+      ...state,
+      buffer,
+      hasFoundValidBoundary,
+      isFinished: true,
+      stage: "boundary"
+    };
+  }
+  if (buffer.length >= 2 && buffer.subarray(0, 2).equals(Buffer.from("\r\n"))) {
+    buffer = buffer.subarray(2);
+  }
+  return {
+    ...state,
+    buffer,
+    hasFoundValidBoundary,
+    stage: "headers",
+    currentHeaders: ""
+  };
+}
+async function processHeaders(state) {
+  const headerEnd = state.buffer.indexOf("\r\n\r\n");
+  if (headerEnd === -1) return state;
+  const headers = state.buffer.subarray(0, headerEnd).toString("utf8");
+  const buffer = state.buffer.subarray(headerEnd + 4);
+  const disposition = parseContentDisposition(headers);
+  if (!disposition) {
+    const { ValidationError: ValidationError2 } = await import("./validation-error-CM6IKIJU.js");
+    throw new ValidationError2("Missing or invalid Content-Disposition header");
+  }
+  const mimetype = parseContentType(headers);
+  const isFile = disposition.filename !== void 0;
+  if (isFile && state.fileCount >= state.options.maxFiles) {
+    const { PayloadTooLargeError } = await import("./payload-too-large-error-PAYLDBZT.js");
+    throw new PayloadTooLargeError("Too many files in upload", {
+      fileCount: state.fileCount + 1,
+      maxFiles: state.options.maxFiles,
+      filename: disposition.filename
+    });
+  }
+  if (isFile && state.options.allowedMimeTypes.length > 0 && !state.options.allowedMimeTypes.includes(mimetype)) {
+    const { UnsupportedMediaTypeError } = await import("./unsupported-media-type-error-MQZD7YQJ.js");
+    throw new UnsupportedMediaTypeError("File type not allowed", {
+      receivedMimeType: mimetype,
+      allowedMimeTypes: state.options.allowedMimeTypes,
+      filename: disposition.filename
+    });
+  }
+  return {
+    ...state,
+    buffer,
+    stage: "content",
+    currentHeaders: headers,
+    currentField: disposition.name,
+    currentFilename: disposition.filename,
+    currentMimetype: mimetype,
+    currentContentLength: 0,
+    fileCount: isFile ? state.fileCount + 1 : state.fileCount,
+    fieldCount: isFile ? state.fieldCount : state.fieldCount + 1,
+    currentBufferChunks: []
+  };
+}
+async function processContent(state) {
+  const nextBoundaryIndex = state.buffer.indexOf(state.boundary);
+  let contentChunk;
+  let isComplete = false;
+  let buffer = state.buffer;
+  if (nextBoundaryIndex === -1) {
+    const safeLength = Math.max(0, state.buffer.length - state.boundary.length);
+    if (safeLength === 0) return state;
+    contentChunk = state.buffer.subarray(0, safeLength);
+    buffer = state.buffer.subarray(safeLength);
+  } else {
+    const contentEnd = Math.max(0, nextBoundaryIndex - 2);
+    contentChunk = state.buffer.subarray(0, contentEnd);
+    buffer = state.buffer.subarray(nextBoundaryIndex);
+    isComplete = true;
+  }
+  let updatedState = { ...state, buffer };
+  if (contentChunk.length > 0) {
+    updatedState = await processContentChunk(updatedState, contentChunk);
+  }
+  if (isComplete) {
+    updatedState = await finalizeCurrentPart(updatedState);
+    updatedState = {
+      ...updatedState,
+      stage: "boundary",
+      hasProcessedAnyPart: true
+      // Mark that we've processed at least one part
+    };
+  }
+  return updatedState;
+}
+async function processContentChunk(state, chunk) {
+  const newContentLength = state.currentContentLength + chunk.length;
+  const maxSize = state.currentFilename !== void 0 ? state.options.maxFileSize : state.options.maxFieldSize;
+  if (newContentLength > maxSize) {
+    const isFile = state.currentFilename !== void 0;
+    const { PayloadTooLargeError } = await import("./payload-too-large-error-PAYLDBZT.js");
+    const payloadErrorDetals = state.currentField ? {
+      contentType: isFile ? "file" : "field",
+      currentSize: newContentLength,
+      maxSize,
+      field: state.currentField,
+      filename: state.currentFilename
+    } : {
+      contentType: isFile ? "file" : "field",
+      currentSize: newContentLength,
+      maxSize,
+      filename: state.currentFilename
+    };
+    throw new PayloadTooLargeError(
+      `${isFile ? "File" : "Field"} size exceeds limit`,
+      payloadErrorDetals
+    );
+  }
+  if (state.currentFilename !== void 0) {
+    return processFileChunk(state, chunk, newContentLength);
+  } else {
+    return {
+      ...state,
+      currentContentLength: newContentLength,
+      currentBufferChunks: [...state.currentBufferChunks, chunk]
+    };
+  }
+}
+async function processFileChunk(state, chunk, newContentLength) {
+  switch (state.options.strategy) {
+    case "memory":
+      return {
+        ...state,
+        currentContentLength: newContentLength,
+        currentBufferChunks: [...state.currentBufferChunks, chunk]
+      };
+    case "stream":
+      if (state.streamController) {
+        state.streamController.enqueue(chunk);
+      }
+      return { ...state, currentContentLength: newContentLength };
+    case "temp":
+      if (state.currentWriteStream) {
+        await writeToStream(state.currentWriteStream, chunk);
+      }
+      return { ...state, currentContentLength: newContentLength };
+    default: {
+      const { ValidationError: ValidationError2 } = await import("./validation-error-CM6IKIJU.js");
+      throw new ValidationError2(`Invalid parsing strategy`);
+    }
+  }
+}
+async function initializeFileProcessing(state) {
+  if (state.currentFilename === void 0) return state;
+  switch (state.options.strategy) {
+    case "memory":
+      return { ...state, currentBufferChunks: [] };
+    case "stream": {
+      let streamController = null;
+      const stream = new ReadableStream({
+        start: (controller) => {
+          streamController = controller;
+        }
+      });
+      return {
+        ...state,
+        currentStream: stream,
+        // Type cast for Node.js compatibility
+        streamController
+      };
+    }
+    case "temp": {
+      const tempPath = join2(state.options.tempDir, `upload-${randomUUID()}`);
+      const writeStream = createWriteStream(tempPath);
+      const cleanupTask = async () => {
+        try {
+          const { unlink } = await import("node:fs/promises");
+          await unlink(tempPath);
+        } catch (error) {
+          console.warn(`Failed to cleanup temp file: ${tempPath}`, error);
+        }
+      };
+      return {
+        ...state,
+        currentTempPath: tempPath,
+        currentWriteStream: writeStream,
+        cleanupTasks: [...state.cleanupTasks, cleanupTask]
+      };
+    }
+    default: {
+      const { ValidationError: ValidationError2 } = await import("./validation-error-CM6IKIJU.js");
+      throw new ValidationError2(`Invalid file processing strategy`);
+    }
+  }
+}
+async function finalizeCurrentPart(state) {
+  if (!state.currentField) return resetCurrentPart(state);
+  if (state.currentFilename !== void 0) {
+    return finalizeFile(state);
+  } else {
+    return finalizeField(state);
+  }
+}
+async function finalizeFile(state) {
+  if (!state.currentField || state.currentFilename === void 0) {
+    return resetCurrentPart(state);
+  }
+  let stream;
+  let buffer;
+  let tempPath;
+  switch (state.options.strategy) {
+    case "memory":
+      buffer = Buffer.concat(state.currentBufferChunks);
+      stream = Readable.from(buffer);
+      break;
+    case "stream":
+      if (state.streamController) {
+        state.streamController.close();
+      }
+      stream = state.currentStream;
+      break;
+    case "temp":
+      if (state.currentWriteStream) {
+        await closeStream(state.currentWriteStream);
+      }
+      tempPath = state.currentTempPath;
+      stream = Readable.from(Buffer.alloc(0));
+      break;
+    default: {
+      const { ValidationError: ValidationError2 } = await import("./validation-error-CM6IKIJU.js");
+      throw new ValidationError2(`Invalid file finalization strategy`);
+    }
+  }
+  const file = {
+    filename: state.currentFilename,
+    fieldname: state.currentField,
+    mimetype: state.currentMimetype,
+    size: state.currentContentLength,
+    stream,
+    buffer,
+    tempPath
+  };
+  const updatedFiles = addToCollection(state.files, state.currentField, file);
+  return {
+    ...resetCurrentPart(state),
+    files: updatedFiles
+  };
+}
+function finalizeField(state) {
+  if (!state.currentField) return resetCurrentPart(state);
+  const value = Buffer.concat(state.currentBufferChunks).toString("utf8");
+  const updatedFields = addToCollection(state.fields, state.currentField, value);
+  return {
+    ...resetCurrentPart(state),
+    fields: updatedFields
+  };
+}
+function resetCurrentPart(state) {
+  return {
+    ...state,
+    currentField: null,
+    currentFilename: void 0,
+    currentContentLength: 0,
+    currentBufferChunks: [],
+    currentStream: null,
+    streamController: null,
+    currentTempPath: null,
+    currentWriteStream: null
+  };
+}
+function addToCollection(collection, key, value) {
+  const newCollection = new Map(collection);
+  const existing = newCollection.get(key) || [];
+  newCollection.set(key, [...existing, value]);
+  return newCollection;
+}
+async function finalize(state) {
+  if (!state.hasFoundValidBoundary) {
+    const { ValidationError: ValidationError2 } = await import("./validation-error-CM6IKIJU.js");
+    throw new ValidationError2("No valid multipart boundary found");
+  }
+  if (state.hasFoundValidBoundary && !state.hasProcessedAnyPart) {
+    const { ValidationError: ValidationError2 } = await import("./validation-error-CM6IKIJU.js");
+    throw new ValidationError2("Empty multipart request");
+  }
+  const fields = {};
+  for (const [key, values] of state.fields.entries()) {
+    fields[key] = values.length === 1 ? values[0] : values;
+  }
+  const files = {};
+  for (const [key, fileList] of state.files.entries()) {
+    files[key] = fileList.length === 1 ? fileList[0] : fileList;
+  }
+  return { fields, files };
+}
+async function cleanup(state) {
+  await Promise.allSettled(state.cleanupTasks.map((task) => task()));
+  if (state.streamController) {
+    state.streamController.close();
+  }
+  if (state.currentWriteStream) {
+    await closeStream(state.currentWriteStream);
+  }
+}
+async function writeToStream(stream, chunk) {
+  return new Promise((resolve3, reject) => {
+    stream.write(chunk, (error) => {
+      if (error) reject(error);
+      else resolve3();
+    });
+  });
+}
+async function closeStream(stream) {
+  return new Promise((resolve3) => {
+    stream.end(() => resolve3());
+  });
+}
+async function parseMultipartRequest(request, options = {}) {
+  const contentType = request.headers["content-type"] || "";
+  const boundary = extractBoundary(contentType);
+  if (!boundary) {
+    const { UnsupportedMediaTypeError } = await import("./unsupported-media-type-error-MQZD7YQJ.js");
+    throw new UnsupportedMediaTypeError("Missing boundary in multipart content-type", {
+      receivedContentType: contentType,
+      expectedFormat: "multipart/form-data; boundary=..."
+    });
+  }
+  let state = createParserState(boundary, options);
+  if (state.currentFilename !== void 0) {
+    state = await initializeFileProcessing(state);
+  }
+  try {
+    for await (const chunk of request) {
+      state = await processChunk(state, chunk);
+    }
+    return finalize(state);
+  } finally {
+    await cleanup(state);
+  }
+}
+
 // src/context/create.ts
 var CONTENT_TYPE_HEADER = "Content-Type";
+var DEFAULT_BODY_LIMITS = {
+  json: 512 * 1024,
+  // 512KB - Most APIs should be much smaller
+  form: 1024 * 1024,
+  // 1MB - Reasonable for form submissions
+  text: 5 * 1024 * 1024,
+  // 5MB - Documents, logs, code files
+  multipart: {
+    maxFileSize: 50 * 1024 * 1024,
+    // 50MB per file
+    maxTotalSize: 100 * 1024 * 1024,
+    // 100MB total request
+    maxFiles: 10,
+    maxFieldSize: 1024 * 1024
+    // 1MB for form fields
+  },
+  raw: 10 * 1024 * 1024
+  // 10MB for unknown content types
+};
 function parseRequestUrl(req) {
   const originalUrl = req.url || "/";
   const host = req.headers.host || "localhost";
@@ -389,7 +875,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 +888,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 +910,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 +919,7 @@ async function createContext(req, res, options = {}) {
   const responseState = { sent: false };
   const ctx = {
     request: createRequestObject(req, {
-      path: path5,
+      path: path6,
       url,
       query,
       params,
@@ -446,7 +932,7 @@ async function createContext(req, res, options = {}) {
   };
   ctx.response = createResponseObject(res, responseState, ctx);
   if (options.parseBody) {
-    await parseBodyIfNeeded(req, ctx);
+    await parseBodyIfNeeded(req, ctx, options);
   }
   return ctx;
 }
@@ -622,34 +1108,60 @@ function createStreamResponder(res, responseState) {
     });
   };
 }
-async function parseBodyIfNeeded(req, ctx) {
+async function parseBodyIfNeeded(req, ctx, options = {}) {
   if (shouldSkipParsing(req.method)) {
     return;
   }
   const contentType = req.headers["content-type"] || "";
   const contentLength = parseInt(req.headers["content-length"] || "0", 10);
-  if (contentLength === 0 || contentLength > 1048576) {
+  if (contentLength === 0) {
     return;
   }
+  const limits = {
+    json: options.bodyLimits?.json ?? DEFAULT_BODY_LIMITS.json,
+    form: options.bodyLimits?.form ?? DEFAULT_BODY_LIMITS.form,
+    text: options.bodyLimits?.text ?? DEFAULT_BODY_LIMITS.text,
+    raw: options.bodyLimits?.raw ?? DEFAULT_BODY_LIMITS.raw,
+    multipart: {
+      maxFileSize: options.bodyLimits?.multipart?.maxFileSize ?? DEFAULT_BODY_LIMITS.multipart.maxFileSize,
+      maxFiles: options.bodyLimits?.multipart?.maxFiles ?? DEFAULT_BODY_LIMITS.multipart.maxFiles,
+      maxFieldSize: options.bodyLimits?.multipart?.maxFieldSize ?? DEFAULT_BODY_LIMITS.multipart.maxFieldSize,
+      maxTotalSize: options.bodyLimits?.multipart?.maxTotalSize ?? DEFAULT_BODY_LIMITS.multipart.maxTotalSize
+    }
+  };
   try {
-    await parseBodyByContentType(req, ctx, contentType);
+    if (contentType.includes("application/json")) {
+      if (contentLength > limits.json) {
+        throw new Error(`JSON body too large: ${contentLength} > ${limits.json} bytes`);
+      }
+      await parseJsonBody(req, ctx);
+    } else if (contentType.includes("application/x-www-form-urlencoded")) {
+      if (contentLength > limits.form) {
+        throw new Error(`Form body too large: ${contentLength} > ${limits.form} bytes`);
+      }
+      await parseFormUrlEncodedBody(req, ctx);
+    } else if (contentType.includes("text/")) {
+      if (contentLength > limits.text) {
+        throw new Error(`Text body too large: ${contentLength} > ${limits.text} bytes`);
+      }
+      await parseTextBody(req, ctx);
+    } else if (isMultipartContent(contentType)) {
+      await parseMultipartBody(req, ctx, limits.multipart);
+    } else {
+      if (contentLength > limits.raw) {
+        throw new Error(`Request body too large: ${contentLength} > ${limits.raw} bytes`);
+      }
+      return;
+    }
   } catch (error) {
-    setBodyError(ctx, "body_read_error", "Error reading request body", error);
+    const errorType = contentType.includes("multipart") ? "multipart_parse_error" : "body_read_error";
+    setBodyError(ctx, errorType, "Error reading request body", error);
   }
 }
 function shouldSkipParsing(method) {
   const skipMethods = ["GET", "HEAD", "OPTIONS"];
   return skipMethods.includes(method || "GET");
 }
-async function parseBodyByContentType(req, ctx, contentType) {
-  if (contentType.includes("application/json")) {
-    await parseJsonBody(req, ctx);
-  } else if (contentType.includes("application/x-www-form-urlencoded")) {
-    await parseFormUrlEncodedBody(req, ctx);
-  } else if (contentType.includes("text/")) {
-    await parseTextBody(req, ctx);
-  }
-}
 async function parseJsonBody(req, ctx) {
   const body = await readRequestBody(req);
   if (!body) {
@@ -701,17 +1213,36 @@ async function parseTextBody(req, ctx) {
     ctx.request.body = body;
   }
 }
+async function parseMultipartBody(req, ctx, multipartLimits) {
+  try {
+    const limits = multipartLimits || DEFAULT_BODY_LIMITS.multipart;
+    const multipartData = await parseMultipartRequest(req, {
+      strategy: "stream",
+      maxFileSize: limits.maxFileSize,
+      maxFiles: limits.maxFiles,
+      maxFieldSize: limits.maxFieldSize
+      // Could add total size validation here
+    });
+    ctx.request.multipart = multipartData;
+    ctx.request.files = multipartData.files;
+    ctx.request.body = multipartData.fields;
+  } catch (error) {
+    ctx.request.body = null;
+    setBodyError(ctx, "multipart_parse_error", "Failed to parse multipart data", error);
+  }
+}
 function setBodyError(ctx, type, message, error) {
-  ctx.state._bodyError = { type, message, error };
+  const bodyError = { type, message, error };
+  ctx.state._bodyError = bodyError;
 }
 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);
@@ -719,6 +1250,102 @@ async function readRequestBody(req) {
   });
 }
 
+// src/errors/not-found-error.ts
+var NotFoundError = class extends BlaizeError {
+  /**
+   * Creates a new NotFoundError instance
+   *
+   * @param title - Human-readable error message
+   * @param details - Optional context about the missing resource
+   * @param correlationId - Optional correlation ID (uses current context if not provided)
+   */
+  constructor(title, details = void 0, correlationId = void 0) {
+    super(
+      "NOT_FOUND" /* NOT_FOUND */,
+      title,
+      404,
+      // HTTP 404 Not Found
+      correlationId ?? getCurrentCorrelationId(),
+      details
+    );
+  }
+};
+
+// src/errors/boundary.ts
+function isHandledError(error) {
+  return error instanceof BlaizeError;
+}
+function formatErrorResponse(error) {
+  if (isHandledError(error)) {
+    return {
+      type: error.type,
+      title: error.title,
+      status: error.status,
+      correlationId: error.correlationId,
+      timestamp: error.timestamp.toISOString(),
+      details: error.details
+    };
+  }
+  const correlationId = generateCorrelationId();
+  let originalMessage;
+  if (error instanceof Error) {
+    originalMessage = error.message;
+  } else if (error === null || error === void 0) {
+    originalMessage = "Unknown error occurred";
+  } else {
+    originalMessage = String(error);
+  }
+  const wrappedError = new InternalServerError(
+    "Internal Server Error",
+    { originalMessage },
+    correlationId
+  );
+  return {
+    type: wrappedError.type,
+    title: wrappedError.title,
+    status: wrappedError.status,
+    correlationId: wrappedError.correlationId,
+    timestamp: wrappedError.timestamp.toISOString(),
+    details: wrappedError.details
+  };
+}
+function extractOrGenerateCorrelationId(headerGetter) {
+  return headerGetter("x-correlation-id") ?? generateCorrelationId();
+}
+function setErrorResponseHeaders(headerSetter, correlationId) {
+  headerSetter("x-correlation-id", correlationId);
+}
+
+// src/middleware/error-boundary.ts
+function createErrorBoundary(options = {}) {
+  const { debug = false } = options;
+  const middlewareFn = async (ctx, next) => {
+    try {
+      await next();
+    } catch (error) {
+      if (ctx.response.sent) {
+        if (debug) {
+          console.error("Error occurred after response was sent:", error);
+        }
+        return;
+      }
+      if (debug) {
+        console.error("Error boundary caught error:", error);
+      }
+      const correlationId = extractOrGenerateCorrelationId(ctx.request.header);
+      const errorResponse = formatErrorResponse(error);
+      errorResponse.correlationId = correlationId;
+      setErrorResponseHeaders(ctx.response.header, correlationId);
+      ctx.response.status(errorResponse.status).json(errorResponse);
+    }
+  };
+  return {
+    name: "ErrorBoundary",
+    execute: middlewareFn,
+    debug
+  };
+}
+
 // src/server/request-handler.ts
 function createRequestHandler(serverInstance) {
   return async (req, res) => {
@@ -727,32 +1354,20 @@ function createRequestHandler(serverInstance) {
         parseBody: true
         // Enable automatic body parsing
       });
-      const handler = compose(serverInstance.middleware);
+      const errorBoundary = createErrorBoundary();
+      const allMiddleware = [errorBoundary, ...serverInstance.middleware];
+      const handler = compose(allMiddleware);
       await runWithContext(context, async () => {
-        try {
-          await handler(context, async () => {
+        await handler(context, async () => {
+          if (!context.response.sent) {
+            await serverInstance.router.handleRequest(context);
             if (!context.response.sent) {
-              await serverInstance.router.handleRequest(context);
-              if (!context.response.sent) {
-                context.response.status(404).json({
-                  error: "Not Found",
-                  message: `Route not found: ${context.request.method} ${context.request.path}`
-                });
-              }
+              throw new NotFoundError(
+                `Route not found: ${context.request.method} ${context.request.path}`
+              );
             }
-          });
-        } catch (error) {
-          console.error("Error processing request:", error);
-          if (!context.response.sent) {
-            context.response.json(
-              {
-                error: "Internal Server Error",
-                message: process.env.NODE_ENV === "development" ? error || "Unknown error" : "An error occurred processing your request"
-              },
-              500
-            );
           }
-        }
+        });
       });
     } catch (error) {
       console.error("Error creating context:", error);
@@ -809,7 +1424,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 +1441,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 +1485,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 +1812,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 +1851,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 +1863,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 +1881,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 +2112,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 +2150,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,88 +2204,12 @@ function watchRoutes(routesDir, options = {}) {
       }
       return allRoutes;
     },
-    /**
-     * Get routes organized by file path
-     */
     getRoutesByFile: () => new Map(routesByPath)
   };
 }
 
-// src/router/handlers/error.ts
-function handleRouteError(ctx, error, options = {}) {
-  if (options.log) {
-    console.error("Route error:", error);
-  }
-  const status = getErrorStatus(error);
-  const response = {
-    error: getErrorType(error),
-    message: getErrorMessage(error)
-  };
-  if (options.detailed) {
-    if (error instanceof Error) {
-      response.stack = error.stack;
-    }
-    if (error && typeof error === "object" && "details" in error && error.details) {
-      response.details = error.details;
-    }
-  }
-  ctx.response.status(status).json(response);
-}
-function getErrorStatus(error) {
-  if (error && typeof error === "object") {
-    if ("status" in error && typeof error.status === "number") {
-      return error.status;
-    }
-    if ("statusCode" in error && typeof error.statusCode === "number") {
-      return error.statusCode;
-    }
-    if ("code" in error && typeof error.code === "string") {
-      return getStatusFromCode(error.code);
-    }
-  }
-  return 500;
-}
-function getStatusFromCode(code) {
-  switch (code) {
-    case "NOT_FOUND":
-      return 404;
-    case "UNAUTHORIZED":
-      return 401;
-    case "FORBIDDEN":
-      return 403;
-    case "BAD_REQUEST":
-      return 400;
-    case "CONFLICT":
-      return 409;
-    default:
-      return 500;
-  }
-}
-function getErrorType(error) {
-  if (error && typeof error === "object") {
-    if ("type" in error && typeof error.type === "string") {
-      return error.type;
-    }
-    if ("name" in error && typeof error.name === "string") {
-      return error.name;
-    }
-    if (error instanceof Error) {
-      return error.constructor.name;
-    }
-  }
-  return "Error";
-}
-function getErrorMessage(error) {
-  if (error instanceof Error) {
-    return error.message;
-  }
-  if (error && typeof error === "object") {
-    if ("message" in error && typeof error.message === "string") {
-      return error.message;
-    }
-  }
-  return String(error);
-}
+// src/router/validation/schema.ts
+import { z as z6 } from "zod";
 
 // src/router/validation/body.ts
 import { z as z2 } from "zod";
@@ -1442,35 +2250,45 @@ function validateResponse(response, schema) {
 // src/router/validation/schema.ts
 function createRequestValidator(schema, debug = false) {
   const middlewareFn = async (ctx, next) => {
-    const errors = {};
     if (schema.params && ctx.request.params) {
       try {
         ctx.request.params = validateParams(ctx.request.params, schema.params);
       } catch (error) {
-        errors.params = formatValidationError(error);
+        const fieldErrors = extractZodFieldErrors(error);
+        const errorCount = fieldErrors.reduce((sum, fe) => sum + fe.messages.length, 0);
+        throw new ValidationError("Request validation failed", {
+          fields: fieldErrors,
+          errorCount,
+          section: "params"
+        });
       }
     }
     if (schema.query && ctx.request.query) {
       try {
         ctx.request.query = validateQuery(ctx.request.query, schema.query);
       } catch (error) {
-        errors.query = formatValidationError(error);
+        const fieldErrors = extractZodFieldErrors(error);
+        const errorCount = fieldErrors.reduce((sum, fe) => sum + fe.messages.length, 0);
+        throw new ValidationError("Request validation failed", {
+          fields: fieldErrors,
+          errorCount,
+          section: "query"
+        });
       }
     }
     if (schema.body) {
       try {
         ctx.request.body = validateBody(ctx.request.body, schema.body);
       } catch (error) {
-        errors.body = formatValidationError(error);
+        const fieldErrors = extractZodFieldErrors(error);
+        const errorCount = fieldErrors.reduce((sum, fe) => sum + fe.messages.length, 0);
+        throw new ValidationError("Request validation failed", {
+          fields: fieldErrors,
+          errorCount,
+          section: "body"
+        });
       }
     }
-    if (Object.keys(errors).length > 0) {
-      ctx.response.status(400).json({
-        error: "Validation Error",
-        details: errors
-      });
-      return;
-    }
     await next();
   };
   return {
@@ -1489,12 +2307,11 @@ function createResponseValidator(responseSchema, debug = false) {
         return originalJson.call(ctx.response, validatedBody, status);
       } catch (error) {
         ctx.response.json = originalJson;
-        console.error("Response validation error:", error);
-        ctx.response.status(500).json({
-          error: "Internal Server Error",
-          message: "Response validation failed"
+        throw new InternalServerError("Response validation failed", {
+          responseSchema: responseSchema.description || "Unknown schema",
+          validationError: extractZodFieldErrors(error),
+          originalResponse: body
         });
-        return ctx.response;
       }
     };
     await next();
@@ -1505,11 +2322,25 @@ function createResponseValidator(responseSchema, debug = false) {
     debug
   };
 }
-function formatValidationError(error) {
-  if (error && typeof error === "object" && "format" in error && typeof error.format === "function") {
-    return error.format();
+function extractZodFieldErrors(error) {
+  if (error instanceof z6.ZodError) {
+    const fieldErrorMap = /* @__PURE__ */ new Map();
+    for (const issue of error.issues) {
+      const fieldPath = issue.path.length > 0 ? issue.path.join(".") : "root";
+      if (!fieldErrorMap.has(fieldPath)) {
+        fieldErrorMap.set(fieldPath, []);
+      }
+      fieldErrorMap.get(fieldPath).push(issue.message);
+    }
+    return Array.from(fieldErrorMap.entries()).map(([field, messages]) => ({
+      field,
+      messages
+    }));
+  }
+  if (error instanceof Error) {
+    return [{ field: "unknown", messages: [error.message] }];
   }
-  return error instanceof Error ? error.message : String(error);
+  return [{ field: "unknown", messages: [String(error)] }];
 }
 
 // src/router/handlers/executor.ts
@@ -1533,8 +2364,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 +2375,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 +2406,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 +2422,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 +2456,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 +2480,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 +2581,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 +2639,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 +2766,22 @@ 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) {
-        ctx.response.status(404).json({ error: "Not Found" });
-        return;
+        console.log(`\u274C No match found for: ${method} ${path6}`);
+        throw new NotFoundError("Not found");
       }
+      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) {
@@ -1831,29 +2790,31 @@ function createRouter(options) {
         return;
       }
       ctx.request.params = match.params;
-      try {
-        await executeHandler(ctx, match.route, match.params);
-      } catch (error) {
-        handleRouteError(ctx, error, {
-          detailed: process.env.NODE_ENV !== "production",
-          log: true
-        });
-      }
+      await executeHandler(ctx, match.route, match.params);
     },
     /**
-     * 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 multiple routes programmatically with batch processing
+     */
+    addRoutes(routes) {
+      const changes = updateRoutesFromFile(registry, "programmatic", routes);
+      applyMatcherChanges(changes);
+      return changes;
     },
     /**
-     * Add a route directory (for plugins)
+     * Add a route directory (for plugins) with optimized loading
      */
     async addRouteDirectory(directory, options2 = {}) {
       if (routeDirectories.has(directory)) {
@@ -1864,27 +2825,33 @@ 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;
     }
   };
 }
 
 // src/server/create.ts
-var DEFAULT_OPTIONS = {
+var DEFAULT_OPTIONS2 = {
   port: 3e3,
   host: "localhost",
   routesDir: "./routes",
@@ -1895,7 +2862,7 @@ var DEFAULT_OPTIONS = {
   plugins: []
 };
 function createServerOptions(options = {}) {
-  const baseOptions = { ...DEFAULT_OPTIONS };
+  const baseOptions = { ...DEFAULT_OPTIONS2 };
   setRuntimeConfig({ routesDir: options.routesDir || baseOptions.routesDir });
   return {
     port: options.port ?? baseOptions.port,
@@ -2015,6 +2982,90 @@ function create3(options = {}) {
   return serverInstance;
 }
 
+// src/errors/unauthorized-error.ts
+var UnauthorizedError = class extends BlaizeError {
+  /**
+   * Creates a new UnauthorizedError instance
+   *
+   * @param title - Human-readable error message
+   * @param details - Optional authentication context
+   * @param correlationId - Optional correlation ID (uses current context if not provided)
+   */
+  constructor(title, details = void 0, correlationId = void 0) {
+    super(
+      "UNAUTHORIZED" /* UNAUTHORIZED */,
+      title,
+      401,
+      // HTTP 401 Unauthorized
+      correlationId ?? getCurrentCorrelationId(),
+      details
+    );
+  }
+};
+
+// src/errors/forbidden-error.ts
+var ForbiddenError = class extends BlaizeError {
+  /**
+   * Creates a new ForbiddenError instance
+   *
+   * @param title - Human-readable error message
+   * @param details - Optional permission context
+   * @param correlationId - Optional correlation ID (uses current context if not provided)
+   */
+  constructor(title, details = void 0, correlationId = void 0) {
+    super(
+      "FORBIDDEN" /* FORBIDDEN */,
+      title,
+      403,
+      // HTTP 403 Forbidden
+      correlationId ?? getCurrentCorrelationId(),
+      details
+    );
+  }
+};
+
+// src/errors/conflict-error.ts
+var ConflictError = class extends BlaizeError {
+  /**
+   * Creates a new ConflictError instance
+   *
+   * @param title - Human-readable error message
+   * @param details - Optional conflict context
+   * @param correlationId - Optional correlation ID (uses current context if not provided)
+   */
+  constructor(title, details = void 0, correlationId = void 0) {
+    super(
+      "CONFLICT" /* CONFLICT */,
+      title,
+      409,
+      // HTTP 409 Conflict
+      correlationId ?? getCurrentCorrelationId(),
+      details
+    );
+  }
+};
+
+// src/errors/rate-limit-error.ts
+var RateLimitError = class extends BlaizeError {
+  /**
+   * Creates a new RateLimitError instance
+   *
+   * @param title - Human-readable error message
+   * @param details - Optional rate limit context
+   * @param correlationId - Optional correlation ID (uses current context if not provided)
+   */
+  constructor(title, details = void 0, correlationId = void 0) {
+    super(
+      "RATE_LIMITED" /* RATE_LIMITED */,
+      title,
+      429,
+      // HTTP 429 Too Many Requests
+      correlationId ?? getCurrentCorrelationId(),
+      details
+    );
+  }
+};
+
 // src/index.ts
 var VERSION = "0.1.0";
 var ServerAPI = { createServer: create3 };
@@ -2045,11 +3096,21 @@ var Blaize = {
 var index_default = Blaize;
 export {
   Blaize,
+  BlaizeError,
+  ConflictError,
+  ErrorSeverity,
+  ErrorType,
+  ForbiddenError,
+  InternalServerError,
   MiddlewareAPI,
+  NotFoundError,
   PluginsAPI,
+  RateLimitError,
   RouterAPI,
   ServerAPI,
+  UnauthorizedError,
   VERSION,
+  ValidationError,
   compose,
   createDeleteRoute,
   createGetRoute,
@@ -2061,6 +3122,7 @@ export {
   createPostRoute,
   createPutRoute,
   create3 as createServer,
-  index_default as default
+  index_default as default,
+  isBodyParseError
 };
 //# sourceMappingURL=index.js.map