blaizejs 0.2.0 → 0.2.3

package/dist/index.cjs

@@ -1,6 +1,6 @@
 /**
- * blaizejs v0.1.0
- * A blazing-fast, type-safe Node.js framework with file-based routing, powerful middleware, and end-to-end type safety
+ * 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
@@ -59,31 +59,6 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/middleware/create.ts
-function create(handlerOrOptions) {
-  if (typeof handlerOrOptions === "function") {
-    return {
-      name: "anonymous",
-      // Default name for function middleware
-      execute: handlerOrOptions,
-      debug: false
-    };
-  }
-  const { name = "anonymous", handler, skip, debug = false } = handlerOrOptions;
-  const middleware = {
-    name,
-    execute: handler,
-    debug
-  };
-  if (skip !== void 0) {
-    return {
-      ...middleware,
-      skip
-    };
-  }
-  return middleware;
-}
-
 // src/middleware/execute.ts
 function execute(middleware, ctx, next) {
   if (!middleware) {
@@ -131,6 +106,31 @@ function compose(middlewareStack) {
   };
 }
 
+// src/middleware/create.ts
+function create(handlerOrOptions) {
+  if (typeof handlerOrOptions === "function") {
+    return {
+      name: "anonymous",
+      // Default name for function middleware
+      execute: handlerOrOptions,
+      debug: false
+    };
+  }
+  const { name = "anonymous", handler, skip, debug = false } = handlerOrOptions;
+  const middleware = {
+    name,
+    execute: handler,
+    debug
+  };
+  if (skip !== void 0) {
+    return {
+      ...middleware,
+      skip
+    };
+  }
+  return middleware;
+}
+
 // src/plugins/create.ts
 function create2(name, version, setup, defaultOptions = {}) {
   if (!name || typeof name !== "string") {
@@ -159,48 +159,23 @@ function create2(name, version, setup, defaultOptions = {}) {
   };
 }
 
-// src/router/discovery/finder.ts
-var fs = __toESM(require("fs/promises"), 1);
-var path = __toESM(require("path"), 1);
-async function findRouteFiles(routesDir, options = {}) {
-  const absoluteDir = path.isAbsolute(routesDir) ? routesDir : path.resolve(process.cwd(), routesDir);
-  console.log("Creating router with routes directory:", absoluteDir);
-  try {
-    const stats = await fs.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 fs.readdir(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = path.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;
+// src/router/create.ts
+var import_node_url = require("url");
+
+// src/config.ts
+var config = {};
+function setRuntimeConfig(newConfig) {
+  config = { ...config, ...newConfig };
 }
-function isRouteFile(filename) {
-  return !filename.startsWith("_") && (filename.endsWith(".ts") || filename.endsWith(".js"));
+function getRoutesDir() {
+  if (!config.routesDir) {
+    throw new Error("Routes directory not configured. Make sure server is properly initialized.");
+  }
+  return config.routesDir;
 }
 
 // src/router/discovery/parser.ts
-var path2 = __toESM(require("path"), 1);
+var path = __toESM(require("path"), 1);
 function parseRoutePath(filePath, basePath) {
   if (filePath.startsWith("file://")) {
     filePath = filePath.replace("file://", "");
@@ -220,7 +195,7 @@ function parseRoutePath(filePath, basePath) {
       relativePath = relativePath.substring(1);
     }
   } else {
-    relativePath = path2.relative(forwardSlashBasePath, forwardSlashFilePath).replace(/\\/g, "/");
+    relativePath = path.relative(forwardSlashBasePath, forwardSlashFilePath).replace(/\\/g, "/");
   }
   relativePath = relativePath.replace(/\.[^.]+$/, "");
   const segments = relativePath.split("/").filter(Boolean);
@@ -244,1697 +219,2138 @@ function parseRoutePath(filePath, basePath) {
   };
 }
 
-// src/router/discovery/loader.ts
-async function dynamicImport(filePath) {
-  return import(filePath);
-}
-async function loadRouteModule(filePath, basePath) {
+// src/router/create.ts
+function getCallerFilePath() {
+  const originalPrepareStackTrace = Error.prepareStackTrace;
   try {
-    const parsedRoute = parseRoutePath(filePath, basePath);
-    console.log("parsedRoute:", parsedRoute);
-    const module2 = await dynamicImport(filePath);
-    console.log("Module exports:", Object.keys(module2));
-    const routes = [];
-    if (module2.default && typeof module2.default === "object") {
-      console.log("Found default export:", module2.default);
-      const route = {
-        ...module2.default,
-        path: parsedRoute.routePath
-      };
-      routes.push(route);
+    Error.prepareStackTrace = (_, stack2) => stack2;
+    const stack = new Error().stack;
+    const callerFrame = stack[3];
+    if (!callerFrame || typeof callerFrame.getFileName !== "function") {
+      throw new Error("Unable to determine caller file frame");
     }
-    Object.entries(module2).forEach(([exportName, exportValue]) => {
-      if (exportName === "default" || !exportValue || typeof exportValue !== "object") {
-        return;
-      }
-      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
-          path: parsedRoute.routePath
-        };
-        routes.push(route);
-      }
-    });
-    if (routes.length === 0) {
-      console.warn(`Route file ${filePath} does not export any valid route definitions`);
-      return [];
+    const fileName = callerFrame.getFileName();
+    if (!fileName) {
+      throw new Error("Unable to determine caller file name");
     }
-    console.log(`Loaded ${routes.length} route(s) from ${filePath}`);
-    return routes;
-  } catch (error) {
-    console.error(`Failed to load route module ${filePath}:`, error);
-    return [];
+    if (fileName.startsWith("file://")) {
+      return (0, import_node_url.fileURLToPath)(fileName);
+    }
+    return fileName;
+  } finally {
+    Error.prepareStackTrace = originalPrepareStackTrace;
   }
 }
-function isValidRoute(obj) {
-  if (!obj || typeof obj !== "object") {
-    return false;
-  }
-  const httpMethods = ["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"];
-  const hasHttpMethod = httpMethods.some(
-    (method) => obj[method] && typeof obj[method] === "object" && obj[method].handler
-  );
-  return hasHttpMethod;
+function getRoutePath() {
+  const callerPath = getCallerFilePath();
+  const routesDir = getRoutesDir();
+  const parsedRoute = parseRoutePath(callerPath, routesDir);
+  console.log(`\u{1F50E} Parsed route path: ${parsedRoute.routePath} from file: ${callerPath}`);
+  return parsedRoute.routePath;
 }
-
-// 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);
-    }
+var createGetRoute = (config2) => {
+  validateMethodConfig("GET", config2);
+  const path6 = getRoutePath();
+  return {
+    GET: config2,
+    path: path6
+  };
+};
+var createPostRoute = (config2) => {
+  validateMethodConfig("POST", config2);
+  const path6 = getRoutePath();
+  return {
+    POST: config2,
+    path: path6
+  };
+};
+var createPutRoute = (config2) => {
+  validateMethodConfig("PUT", config2);
+  const path6 = getRoutePath();
+  return {
+    PUT: config2,
+    path: path6
+  };
+};
+var createDeleteRoute = (config2) => {
+  validateMethodConfig("DELETE", config2);
+  const path6 = getRoutePath();
+  return {
+    DELETE: config2,
+    path: path6
+  };
+};
+var createPatchRoute = (config2) => {
+  validateMethodConfig("PATCH", config2);
+  const path6 = getRoutePath();
+  return {
+    PATCH: config2,
+    path: path6
+  };
+};
+var createHeadRoute = (config2) => {
+  validateMethodConfig("HEAD", config2);
+  const path6 = getRoutePath();
+  return {
+    HEAD: config2,
+    path: path6
+  };
+};
+var createOptionsRoute = (config2) => {
+  validateMethodConfig("OPTIONS", config2);
+  const path6 = getRoutePath();
+  return {
+    OPTIONS: config2,
+    path: path6
+  };
+};
+function validateMethodConfig(method, config2) {
+  if (!config2.handler || typeof config2.handler !== "function") {
+    throw new Error(`Handler for method ${method} must be a function`);
   }
-  return routes;
-}
-
-// src/router/discovery/watchers.ts
-var path3 = __toESM(require("path"), 1);
-var import_chokidar = require("chokidar");
-function watchRoutes(routesDir, options = {}) {
-  const routesByPath = /* @__PURE__ */ new Map();
-  async function loadInitialRoutes() {
-    try {
-      const files = await findRouteFiles(routesDir, {
-        ignore: options.ignore
-      });
-      for (const filePath of files) {
-        await loadAndNotify(filePath);
-      }
-    } catch (error) {
-      handleError(error);
-    }
+  if (config2.middleware && !Array.isArray(config2.middleware)) {
+    throw new Error(`Middleware for method ${method} must be an array`);
   }
-  async function loadAndNotify(filePath) {
-    try {
-      const routes = await loadRouteModule(filePath, routesDir);
-      if (!routes || routes.length === 0) {
-        return;
-      }
-      const existingRoutes = routesByPath.get(filePath);
-      if (existingRoutes) {
-        routesByPath.set(filePath, routes);
-        if (options.onRouteChanged) {
-          options.onRouteChanged(routes);
-        }
-      } else {
-        routesByPath.set(filePath, routes);
-        if (options.onRouteAdded) {
-          options.onRouteAdded(routes);
-        }
+  if (config2.schema) {
+    validateSchema(method, config2.schema);
+  }
+  switch (method) {
+    case "GET":
+    case "HEAD":
+    case "DELETE":
+      if (config2.schema?.body) {
+        console.warn(`Warning: ${method} requests typically don't have request bodies`);
       }
-    } catch (error) {
-      handleError(error);
-    }
+      break;
   }
-  function handleRemoved(filePath) {
-    const normalizedPath = path3.normalize(filePath);
-    const routes = routesByPath.get(normalizedPath);
-    if (routes && routes.length > 0 && options.onRouteRemoved) {
-      options.onRouteRemoved(normalizedPath, routes);
-    }
-    routesByPath.delete(normalizedPath);
+}
+function validateSchema(method, schema) {
+  const { params, query, body, response } = schema;
+  if (params && (!params._def || typeof params.parse !== "function")) {
+    throw new Error(`Params schema for ${method} must be a valid Zod schema`);
   }
-  function handleError(error) {
-    if (options.onError && error instanceof Error) {
-      options.onError(error);
-    } else {
-      console.error("Route watcher error:", error);
-    }
+  if (query && (!query._def || typeof query.parse !== "function")) {
+    throw new Error(`Query schema for ${method} must be a valid Zod schema`);
   }
-  const watcher = (0, import_chokidar.watch)(routesDir, {
-    ignored: [
-      /(^|[/\\])\../,
-      // Ignore dot files
-      /node_modules/,
-      ...options.ignore || []
-    ],
-    persistent: true,
-    ignoreInitial: false,
-    awaitWriteFinish: {
-      stabilityThreshold: 300,
-      pollInterval: 100
-    }
-  });
-  watcher.on("add", loadAndNotify).on("change", loadAndNotify).on("unlink", handleRemoved).on("error", handleError);
-  loadInitialRoutes().catch(handleError);
-  return {
-    /**
-     * Close the watcher
-     */
-    close: () => watcher.close(),
-    /**
-     * Get all currently loaded routes (flattened)
-     */
-    getRoutes: () => {
-      const allRoutes = [];
-      for (const routes of routesByPath.values()) {
-        allRoutes.push(...routes);
-      }
-      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);
+  if (body && (!body._def || typeof body.parse !== "function")) {
+    throw new Error(`Body schema for ${method} must be a valid Zod schema`);
   }
-  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;
-    }
+  if (response && (!response._def || typeof response.parse !== "function")) {
+    throw new Error(`Response schema for ${method} must be a valid Zod schema`);
   }
-  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);
-    }
+
+// src/server/create.ts
+var import_node_async_hooks2 = require("async_hooks");
+var import_node_events = __toESM(require("events"), 1);
+
+// src/server/start.ts
+var fs2 = __toESM(require("fs"), 1);
+var http = __toESM(require("http"), 1);
+var http2 = __toESM(require("http2"), 1);
+
+// src/server/dev-certificate.ts
+var fs = __toESM(require("fs"), 1);
+var path2 = __toESM(require("path"), 1);
+var selfsigned = __toESM(require("selfsigned"), 1);
+async function generateDevCertificates() {
+  const certDir = path2.join(process.cwd(), ".blaizejs", "certs");
+  const keyPath = path2.join(certDir, "dev.key");
+  const certPath = path2.join(certDir, "dev.cert");
+  if (fs.existsSync(keyPath) && fs.existsSync(certPath)) {
+    return {
+      keyFile: keyPath,
+      certFile: certPath
+    };
   }
-  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;
+  if (!fs.existsSync(certDir)) {
+    fs.mkdirSync(certDir, { recursive: true });
   }
+  const attrs = [{ name: "commonName", value: "localhost" }];
+  const options = {
+    days: 365,
+    algorithm: "sha256",
+    keySize: 2048,
+    extensions: [
+      { name: "basicConstraints", cA: true },
+      {
+        name: "keyUsage",
+        keyCertSign: true,
+        digitalSignature: true,
+        nonRepudiation: true,
+        keyEncipherment: true,
+        dataEncipherment: true
+      },
+      {
+        name: "extKeyUsage",
+        serverAuth: true,
+        clientAuth: true
+      },
+      {
+        name: "subjectAltName",
+        altNames: [
+          { type: 2, value: "localhost" },
+          { type: 7, ip: "127.0.0.1" }
+        ]
+      }
+    ]
+  };
+  const pems = selfsigned.generate(attrs, options);
+  fs.writeFileSync(keyPath, Buffer.from(pems.private, "utf-8"));
+  fs.writeFileSync(certPath, Buffer.from(pems.cert, "utf-8"));
+  console.log(`
+\u{1F512} Generated self-signed certificates for development at ${certDir}
+`);
+  return {
+    keyFile: keyPath,
+    certFile: certPath
+  };
 }
-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;
-    }
+
+// src/context/errors.ts
+var ResponseSentError = class extends Error {
+  constructor(message = "\u274C Response has already been sent") {
+    super(message);
+    this.name = "ResponseSentError";
   }
-  return "Error";
-}
-function getErrorMessage(error) {
-  if (error instanceof Error) {
-    return error.message;
+};
+var ResponseSentHeaderError = class extends ResponseSentError {
+  constructor(message = "Cannot set header after response has been sent") {
+    super(message);
   }
-  if (error && typeof error === "object") {
-    if ("message" in error && typeof error.message === "string") {
-      return error.message;
-    }
+};
+var ResponseSentContentError = class extends ResponseSentError {
+  constructor(message = "Cannot set content type after response has been sent") {
+    super(message);
   }
-  return String(error);
-}
-
-// src/router/validation/body.ts
-var import_zod = require("zod");
-function validateBody(body, schema) {
-  if (schema instanceof import_zod.z.ZodObject) {
-    return schema.strict().parse(body);
+};
+var ParseUrlError = class extends ResponseSentError {
+  constructor(message = "Invalide URL") {
+    super(message);
   }
-  return schema.parse(body);
-}
+};
 
-// src/router/validation/params.ts
-var import_zod2 = require("zod");
-function validateParams(params, schema) {
-  if (schema instanceof import_zod2.z.ZodObject) {
-    return schema.strict().parse(params);
-  }
-  return schema.parse(params);
+// src/context/store.ts
+var import_node_async_hooks = require("async_hooks");
+var contextStorage = new import_node_async_hooks.AsyncLocalStorage();
+function runWithContext(context, callback) {
+  return contextStorage.run(context, callback);
 }
 
-// src/router/validation/query.ts
-var import_zod3 = require("zod");
-function validateQuery(query, schema) {
-  if (schema instanceof import_zod3.z.ZodObject) {
-    return schema.strict().parse(query);
+// src/context/create.ts
+var CONTENT_TYPE_HEADER = "Content-Type";
+function parseRequestUrl(req) {
+  const originalUrl = req.url || "/";
+  const host = req.headers.host || "localhost";
+  const protocol = req.socket && req.socket.encrypted ? "https" : "http";
+  const fullUrl = `${protocol}://${host}${originalUrl.startsWith("/") ? "" : "/"}${originalUrl}`;
+  try {
+    const url = new URL(fullUrl);
+    const path6 = url.pathname;
+    const query = {};
+    url.searchParams.forEach((value, key) => {
+      if (query[key] !== void 0) {
+        if (Array.isArray(query[key])) {
+          query[key].push(value);
+        } else {
+          query[key] = [query[key], value];
+        }
+      } else {
+        query[key] = value;
+      }
+    });
+    return { path: path6, url, query };
+  } catch (error) {
+    console.warn(`Invalid URL: ${fullUrl}`, error);
+    throw new ParseUrlError(`Invalid URL: ${fullUrl}`);
   }
-  return schema.parse(query);
 }
-
-// src/router/validation/response.ts
-var import_zod4 = require("zod");
-function validateResponse(response, schema) {
-  if (schema instanceof import_zod4.z.ZodObject) {
-    return schema.strict().parse(response);
+function isHttp2Request(req) {
+  return "stream" in req || "httpVersionMajor" in req && req.httpVersionMajor === 2;
+}
+function getProtocol(req) {
+  const encrypted = req.socket && req.socket.encrypted;
+  const forwardedProto = req.headers["x-forwarded-proto"];
+  if (forwardedProto) {
+    if (Array.isArray(forwardedProto)) {
+      return forwardedProto[0]?.split(",")[0]?.trim() || "http";
+    } else {
+      return forwardedProto.split(",")[0]?.trim() || "http";
+    }
   }
-  return schema.parse(response);
+  return encrypted ? "https" : "http";
 }
-
-// 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);
-      }
-    }
-    if (schema.query && ctx.request.query) {
-      try {
-        ctx.request.query = validateQuery(ctx.request.query, schema.query);
-      } catch (error) {
-        errors.query = formatValidationError(error);
-      }
-    }
-    if (schema.body) {
-      try {
-        ctx.request.body = validateBody(ctx.request.body, schema.body);
-      } catch (error) {
-        errors.body = formatValidationError(error);
-      }
+async function createContext(req, res, options = {}) {
+  const { path: path6, url, query } = parseRequestUrl(req);
+  const method = req.method || "GET";
+  const isHttp2 = isHttp2Request(req);
+  const protocol = getProtocol(req);
+  const params = {};
+  const state = { ...options.initialState || {} };
+  const responseState = { sent: false };
+  const ctx = {
+    request: createRequestObject(req, {
+      path: path6,
+      url,
+      query,
+      params,
+      method,
+      isHttp2,
+      protocol
+    }),
+    response: {},
+    state
+  };
+  ctx.response = createResponseObject(res, responseState, ctx);
+  if (options.parseBody) {
+    await parseBodyIfNeeded(req, ctx);
+  }
+  return ctx;
+}
+function createRequestObject(req, info) {
+  return {
+    raw: req,
+    ...info,
+    header: createRequestHeaderGetter(req),
+    headers: createRequestHeadersGetter(req),
+    body: void 0
+  };
+}
+function createRequestHeaderGetter(req) {
+  return (name) => {
+    const value = req.headers[name.toLowerCase()];
+    if (Array.isArray(value)) {
+      return value.join(", ");
     }
-    if (Object.keys(errors).length > 0) {
-      ctx.response.status(400).json({
-        error: "Validation Error",
-        details: errors
-      });
-      return;
+    return value || void 0;
+  };
+}
+function createRequestHeadersGetter(req) {
+  const headerGetter = createRequestHeaderGetter(req);
+  return (names) => {
+    if (names && Array.isArray(names) && names.length > 0) {
+      return names.reduce((acc, name) => {
+        acc[name] = headerGetter(name);
+        return acc;
+      }, {});
+    } else {
+      return Object.entries(req.headers).reduce(
+        (acc, [key, value]) => {
+          acc[key] = Array.isArray(value) ? value.join(", ") : value || void 0;
+          return acc;
+        },
+        {}
+      );
     }
-    await next();
   };
+}
+function createResponseObject(res, responseState, ctx) {
   return {
-    name: "RequestValidator",
-    execute: middlewareFn,
-    debug
+    raw: res,
+    get sent() {
+      return responseState.sent;
+    },
+    status: createStatusSetter(res, responseState, ctx),
+    header: createHeaderSetter(res, responseState, ctx),
+    headers: createHeadersSetter(res, responseState, ctx),
+    type: createContentTypeSetter(res, responseState, ctx),
+    json: createJsonResponder(res, responseState),
+    text: createTextResponder(res, responseState),
+    html: createHtmlResponder(res, responseState),
+    redirect: createRedirectResponder(res, responseState),
+    stream: createStreamResponder(res, responseState)
   };
 }
-function createResponseValidator(responseSchema, debug = false) {
-  const middlewareFn = async (ctx, next) => {
-    const originalJson = ctx.response.json;
-    ctx.response.json = (body, status) => {
-      try {
-        const validatedBody = validateResponse(body, responseSchema);
-        ctx.response.json = originalJson;
-        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"
-        });
-        return ctx.response;
-      }
-    };
-    await next();
+function createStatusSetter(res, responseState, ctx) {
+  return function statusSetter(code) {
+    if (responseState.sent) {
+      throw new ResponseSentError();
+    }
+    res.statusCode = code;
+    return ctx.response;
   };
-  return {
-    name: "ResponseValidator",
-    execute: middlewareFn,
-    debug
+}
+function createHeaderSetter(res, responseState, ctx) {
+  return function headerSetter(name, value) {
+    if (responseState.sent) {
+      throw new ResponseSentHeaderError();
+    }
+    res.setHeader(name, value);
+    return ctx.response;
   };
 }
-function formatValidationError(error) {
-  if (error && typeof error === "object" && "format" in error && typeof error.format === "function") {
-    return error.format();
-  }
-  return error instanceof Error ? error.message : String(error);
+function createHeadersSetter(res, responseState, ctx) {
+  return function headersSetter(headers) {
+    if (responseState.sent) {
+      throw new ResponseSentHeaderError();
+    }
+    for (const [name, value] of Object.entries(headers)) {
+      res.setHeader(name, value);
+    }
+    return ctx.response;
+  };
 }
-
-// src/router/handlers/executor.ts
-async function executeHandler(ctx, routeOptions, params) {
-  const middleware = [...routeOptions.middleware || []];
-  if (routeOptions.schema) {
-    if (routeOptions.schema.params || routeOptions.schema.query || routeOptions.schema.body) {
-      middleware.unshift(createRequestValidator(routeOptions.schema));
+function createContentTypeSetter(res, responseState, ctx) {
+  return function typeSetter(type) {
+    if (responseState.sent) {
+      throw new ResponseSentContentError();
     }
-    if (routeOptions.schema.response) {
-      middleware.push(createResponseValidator(routeOptions.schema.response));
+    res.setHeader(CONTENT_TYPE_HEADER, type);
+    return ctx.response;
+  };
+}
+function createJsonResponder(res, responseState) {
+  return function jsonResponder(body, status) {
+    if (responseState.sent) {
+      throw new ResponseSentError();
     }
-  }
-  const handler = compose([...middleware]);
-  await handler(ctx, async () => {
-    const result = await routeOptions.handler(ctx, params);
-    if (!ctx.response.sent && result !== void 0) {
-      ctx.response.json(result);
+    if (status !== void 0) {
+      res.statusCode = status;
     }
-  });
+    res.setHeader(CONTENT_TYPE_HEADER, "application/json");
+    res.end(JSON.stringify(body));
+    responseState.sent = true;
+  };
 }
-
-// src/router/matching/params.ts
-function extractParams(path5, pattern, paramNames) {
-  const match = pattern.exec(path5);
-  if (!match) {
-    return {};
-  }
-  const params = {};
-  for (let i = 0; i < paramNames.length; i++) {
-    params[paramNames[i]] = match[i + 1] || "";
-  }
-  return params;
+function createTextResponder(res, responseState) {
+  return function textResponder(body, status) {
+    if (responseState.sent) {
+      throw new ResponseSentError();
+    }
+    if (status !== void 0) {
+      res.statusCode = status;
+    }
+    res.setHeader(CONTENT_TYPE_HEADER, "text/plain");
+    res.end(body);
+    responseState.sent = true;
+  };
 }
-function compilePathPattern(path5) {
-  const paramNames = [];
-  if (path5 === "/") {
-    return {
-      pattern: /^\/$/,
-      paramNames: []
-    };
-  }
-  let patternString = path5.replace(/([.+*?^$(){}|\\])/g, "\\$1");
-  patternString = patternString.replace(/\/:([^/]+)/g, (_, paramName) => {
-    paramNames.push(paramName);
-    return "/([^/]+)";
-  }).replace(/\/\[([^\]]+)\]/g, (_, paramName) => {
-    paramNames.push(paramName);
-    return "/([^/]+)";
-  });
-  patternString = `${patternString}(?:/)?`;
-  const pattern = new RegExp(`^${patternString}$`);
-  return {
-    pattern,
-    paramNames
+function createHtmlResponder(res, responseState) {
+  return function htmlResponder(body, status) {
+    if (responseState.sent) {
+      throw new ResponseSentError();
+    }
+    if (status !== void 0) {
+      res.statusCode = status;
+    }
+    res.setHeader(CONTENT_TYPE_HEADER, "text/html");
+    res.end(body);
+    responseState.sent = true;
   };
 }
-
-// src/router/matching/matcher.ts
-function createMatcher() {
-  const routes = [];
-  return {
-    /**
-     * Add a route to the matcher
-     */
-    add(path5, method, routeOptions) {
-      const { pattern, paramNames } = compilePathPattern(path5);
-      const newRoute = {
-        path: path5,
-        method,
-        pattern,
-        paramNames,
-        routeOptions
-      };
-      const insertIndex = routes.findIndex((route) => paramNames.length < route.paramNames.length);
-      if (insertIndex === -1) {
-        routes.push(newRoute);
-      } else {
-        routes.splice(insertIndex, 0, newRoute);
-      }
-    },
-    /**
-     * Match a URL path to a route
-     */
-    match(path5, method) {
-      const pathname = path5.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);
-          return {
-            route: route.routeOptions,
-            params
-          };
-        }
-      }
-      const matchingPath = routes.find(
-        (route) => route.method !== method && route.pattern.test(path5)
-      );
-      if (matchingPath) {
-        return {
-          route: null,
-          params: {},
-          methodNotAllowed: true,
-          allowedMethods: routes.filter((route) => route.pattern.test(path5)).map((route) => route.method)
-        };
-      }
-      return null;
-    },
-    /**
-     * Get all registered routes
-     */
-    getRoutes() {
-      return routes.map((route) => ({
-        path: route.path,
-        method: route.method
-      }));
-    },
-    /**
-     * Find routes matching a specific path
-     */
-    findRoutes(path5) {
-      return routes.filter((route) => route.pattern.test(path5)).map((route) => ({
-        path: route.path,
-        method: route.method,
-        params: extractParams(path5, route.pattern, route.paramNames)
-      }));
+function createRedirectResponder(res, responseState) {
+  return function redirectResponder(url, status = 302) {
+    if (responseState.sent) {
+      throw new ResponseSentError();
     }
+    res.statusCode = status;
+    res.setHeader("Location", url);
+    res.end();
+    responseState.sent = true;
   };
 }
-
-// src/router/router.ts
-var DEFAULT_ROUTER_OPTIONS = {
-  routesDir: "./routes",
-  basePath: "/",
-  watchMode: process.env.NODE_ENV === "development"
-};
-function createRouter(options) {
-  const routerOptions = {
-    ...DEFAULT_ROUTER_OPTIONS,
-    ...options
-  };
-  if (options.basePath && !options.basePath.startsWith("/")) {
-    console.warn("Base path does nothing");
-  }
-  const routes = [];
-  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 createStreamResponder(res, responseState) {
+  return function streamResponder(readable, options = {}) {
+    if (responseState.sent) {
+      throw new ResponseSentError();
     }
-    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);
-      }
-      console.log(
-        `Loaded ${discoveredRoutes.length} routes from ${source}${prefix ? ` with prefix ${prefix}` : ""}`
-      );
-    } catch (error) {
-      console.error(`Failed to load routes from ${source}:`, error);
-      throw error;
+    if (options.status !== void 0) {
+      res.statusCode = options.status;
     }
-  }
-  async function initialize() {
-    if (initialized || initializationPromise) {
-      return initializationPromise;
+    if (options.contentType) {
+      res.setHeader(CONTENT_TYPE_HEADER, options.contentType);
     }
-    initializationPromise = (async () => {
-      try {
-        for (const directory of routeDirectories) {
-          await loadRoutesFromDirectory(directory, directory);
-        }
-        if (routerOptions.watchMode) {
-          setupWatcherForAllDirectories();
-        }
-        initialized = true;
-      } catch (error) {
-        console.error("Failed to initialize router:", error);
-        throw error;
+    if (options.headers) {
+      for (const [name, value] of Object.entries(options.headers)) {
+        res.setHeader(name, value);
       }
-    })();
-    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);
+    }
+    readable.pipe(res);
+    readable.on("end", () => {
+      responseState.sent = true;
     });
-  }
-  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);
-            }
-          }
-          const finalRoute = prefix ? { ...route, path: finalPath } : route;
-          addRouteWithSource(finalRoute, source);
-        });
-      },
-      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);
-          }
-        });
-      },
-      onError: (error) => {
-        console.error(`Route watcher error for ${directory}:`, error);
+    readable.on("error", (err) => {
+      console.error("Stream error:", err);
+      if (!responseState.sent) {
+        res.statusCode = 500;
+        res.end("Stream error");
+        responseState.sent = true;
       }
-    };
-  }
-  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;
+  };
+}
+async function parseBodyIfNeeded(req, ctx) {
+  if (shouldSkipParsing(req.method)) {
+    return;
   }
-  function setupWatcherForAllDirectories() {
-    for (const directory of routeDirectories) {
-      setupWatcherForDirectory(directory, directory);
-    }
+  const contentType = req.headers["content-type"] || "";
+  const contentLength = parseInt(req.headers["content-length"] || "0", 10);
+  if (contentLength === 0 || contentLength > 1048576) {
+    return;
+  }
+  try {
+    await parseBodyByContentType(req, ctx, contentType);
+  } catch (error) {
+    setBodyError(ctx, "body_read_error", "Error reading request body", error);
   }
-  initialize().catch((error) => {
-    console.error("Failed to initialize router on creation:", error);
-  });
-  return {
-    /**
-     * Handle an incoming request
-     */
-    async handleRequest(ctx) {
-      if (!initialized) {
-        await initialize();
-      }
-      const { method, path: path5 } = ctx.request;
-      const match = matcher.match(path5, method);
-      if (!match) {
-        ctx.response.status(404).json({ error: "Not Found" });
-        return;
-      }
-      if (match.methodNotAllowed) {
-        ctx.response.status(405).json({
-          error: "Method Not Allowed",
-          allowed: match.allowedMethods
-        });
-        if (match.allowedMethods && match.allowedMethods.length > 0) {
-          ctx.response.header("Allow", match.allowedMethods.join(", "));
-        }
-        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
-        });
-      }
-    },
-    /**
-     * Get all registered routes
-     */
-    getRoutes() {
-      return [...routes];
-    },
-    /**
-     * Add a route programmatically
-     */
-    addRoute(route) {
-      addRouteInternal(route);
-    },
-    /**
-     * Add a route directory (for plugins)
-     */
-    async addRouteDirectory(directory, options2 = {}) {
-      if (routeDirectories.has(directory)) {
-        console.warn(`Route directory ${directory} already registered`);
-        return;
-      }
-      routeDirectories.add(directory);
-      if (initialized) {
-        await loadRoutesFromDirectory(directory, directory, options2.prefix);
-        if (routerOptions.watchMode) {
-          setupWatcherForDirectory(directory, directory, options2.prefix);
-        }
-      }
-    },
-    /**
-     * Get route conflicts
-     */
-    getRouteConflicts() {
-      const conflicts = [];
-      for (const [path5, sources] of routeSources.entries()) {
-        if (sources.length > 1) {
-          conflicts.push({ path: path5, sources });
-        }
-      }
-      return conflicts;
-    }
-  };
 }
-
-// src/config.ts
-var config = {};
-function setRuntimeConfig(newConfig) {
-  config = { ...config, ...newConfig };
+function shouldSkipParsing(method) {
+  const skipMethods = ["GET", "HEAD", "OPTIONS"];
+  return skipMethods.includes(method || "GET");
 }
-function getRoutesDir() {
-  if (!config.routesDir) {
-    throw new Error("Routes directory not configured. Make sure server is properly initialized.");
+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);
   }
-  return config.routesDir;
 }
-
-// src/router/create.ts
-function getCallerFilePath() {
-  const originalPrepareStackTrace = Error.prepareStackTrace;
+async function parseJsonBody(req, ctx) {
+  const body = await readRequestBody(req);
+  if (!body) {
+    console.warn("Empty body, skipping JSON parsing");
+    return;
+  }
+  if (body.trim() === "null") {
+    console.warn('Body is the string "null"');
+    ctx.request.body = null;
+    return;
+  }
   try {
-    Error.prepareStackTrace = (_, stack2) => stack2;
-    const stack = new Error().stack;
-    const callerFrame = stack[3];
-    if (!callerFrame || typeof callerFrame.getFileName !== "function") {
-      throw new Error("Unable to determine caller file frame");
-    }
-    const fileName = callerFrame.getFileName();
-    if (!fileName) {
-      throw new Error("Unable to determine caller file name");
+    const json = JSON.parse(body);
+    ctx.request.body = json;
+  } catch (error) {
+    ctx.request.body = null;
+    setBodyError(ctx, "json_parse_error", "Invalid JSON in request body", error);
+  }
+}
+async function parseFormUrlEncodedBody(req, ctx) {
+  const body = await readRequestBody(req);
+  if (!body) return;
+  try {
+    ctx.request.body = parseUrlEncodedData(body);
+  } catch (error) {
+    ctx.request.body = null;
+    setBodyError(ctx, "form_parse_error", "Invalid form data in request body", error);
+  }
+}
+function parseUrlEncodedData(body) {
+  const params = new URLSearchParams(body);
+  const formData = {};
+  params.forEach((value, key) => {
+    if (formData[key] !== void 0) {
+      if (Array.isArray(formData[key])) {
+        formData[key].push(value);
+      } else {
+        formData[key] = [formData[key], value];
+      }
+    } else {
+      formData[key] = value;
     }
-    return fileName;
-  } finally {
-    Error.prepareStackTrace = originalPrepareStackTrace;
+  });
+  return formData;
+}
+async function parseTextBody(req, ctx) {
+  const body = await readRequestBody(req);
+  if (body) {
+    ctx.request.body = body;
   }
 }
-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}`);
-  return parsedRoute.routePath;
+function setBodyError(ctx, type, message, error) {
+  ctx.state._bodyError = { type, message, error };
 }
-var createGetRoute = (config2) => {
-  validateMethodConfig("GET", config2);
-  const path5 = getRoutePath();
-  return {
-    GET: config2,
-    path: path5
-  };
-};
-var createPostRoute = (config2) => {
-  validateMethodConfig("POST", config2);
-  const path5 = getRoutePath();
-  return {
-    POST: config2,
-    path: path5
-  };
-};
-var createPutRoute = (config2) => {
-  validateMethodConfig("PUT", config2);
-  const path5 = getRoutePath();
-  return {
-    PUT: config2,
-    path: path5
-  };
-};
-var createDeleteRoute = (config2) => {
-  validateMethodConfig("DELETE", config2);
-  const path5 = getRoutePath();
-  return {
-    DELETE: config2,
-    path: path5
-  };
-};
-var createPatchRoute = (config2) => {
-  validateMethodConfig("PATCH", config2);
-  const path5 = getRoutePath();
-  return {
-    PATCH: config2,
-    path: path5
-  };
-};
-var createHeadRoute = (config2) => {
-  validateMethodConfig("HEAD", config2);
-  const path5 = getRoutePath();
-  return {
-    HEAD: config2,
-    path: path5
+async function readRequestBody(req) {
+  return new Promise((resolve3, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    });
+    req.on("end", () => {
+      resolve3(Buffer.concat(chunks).toString("utf8"));
+    });
+    req.on("error", (err) => {
+      reject(err);
+    });
+  });
+}
+
+// src/server/request-handler.ts
+function createRequestHandler(serverInstance) {
+  return async (req, res) => {
+    try {
+      const context = await createContext(req, res, {
+        parseBody: true
+        // Enable automatic body parsing
+      });
+      const handler = compose(serverInstance.middleware);
+      await runWithContext(context, async () => {
+        try {
+          await handler(context, async () => {
+            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}`
+                });
+              }
+            }
+          });
+        } 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);
+      res.writeHead(500, { "Content-Type": "application/json" });
+      res.end(
+        JSON.stringify({
+          error: "Internal Server Error",
+          message: "Failed to process request"
+        })
+      );
+    }
   };
-};
-var createOptionsRoute = (config2) => {
-  validateMethodConfig("OPTIONS", config2);
-  const path5 = getRoutePath();
-  return {
-    OPTIONS: config2,
-    path: path5
+}
+
+// src/server/start.ts
+async function prepareCertificates(http2Options) {
+  if (!http2Options.enabled) {
+    return {};
+  }
+  const { keyFile, certFile } = http2Options;
+  const isDevMode = process.env.NODE_ENV === "development";
+  const certificatesMissing = !keyFile || !certFile;
+  if (certificatesMissing && isDevMode) {
+    const devCerts = await generateDevCertificates();
+    return devCerts;
+  }
+  if (certificatesMissing) {
+    throw new Error(
+      "HTTP/2 requires SSL certificates. Provide keyFile and certFile in http2 options. In development, set NODE_ENV=development to generate them automatically."
+    );
+  }
+  return { keyFile, certFile };
+}
+function createServerInstance(isHttp2, certOptions) {
+  if (!isHttp2) {
+    return http.createServer();
+  }
+  const http2ServerOptions = {
+    allowHTTP1: true
+    // Allow fallback to HTTP/1.1
   };
-};
-function validateMethodConfig(method, config2) {
-  if (!config2.handler || typeof config2.handler !== "function") {
-    throw new Error(`Handler for method ${method} must be a function`);
+  try {
+    if (certOptions.keyFile) {
+      http2ServerOptions.key = fs2.readFileSync(certOptions.keyFile);
+    }
+    if (certOptions.certFile) {
+      http2ServerOptions.cert = fs2.readFileSync(certOptions.certFile);
+    }
+  } catch (err) {
+    throw new Error(
+      `Failed to read certificate files: ${err instanceof Error ? err.message : String(err)}`
+    );
   }
-  if (config2.middleware && !Array.isArray(config2.middleware)) {
-    throw new Error(`Middleware for method ${method} must be an array`);
+  return http2.createSecureServer(http2ServerOptions);
+}
+function listenOnPort(server, port, host, isHttp2) {
+  return new Promise((resolve3, reject) => {
+    server.listen(port, host, () => {
+      const protocol = isHttp2 ? "https" : "http";
+      const url = `${protocol}://${host}:${port}`;
+      console.log(`
+\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}
+
+    \u26A1 BlaizeJS DEVELOPMENT SERVER HOT AND READY \u26A1
+    
+    \u{1F680} Server: ${url}
+    \u{1F525} Hot Reload: Enabled
+    \u{1F6E0}\uFE0F  Mode: Development
+    
+    Time to build something amazing! \u{1F680}
+
+\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}
+`);
+      resolve3();
+    });
+    server.on("error", (err) => {
+      console.error("Server error:", err);
+      reject(err);
+    });
+  });
+}
+async function initializePlugins(serverInstance) {
+  for (const plugin of serverInstance.plugins) {
+    if (typeof plugin.initialize === "function") {
+      await plugin.initialize(serverInstance);
+    }
   }
-  if (config2.schema) {
-    validateSchema(method, config2.schema);
+}
+async function startServer(serverInstance, serverOptions) {
+  if (serverInstance.server) {
+    return;
   }
-  switch (method) {
-    case "GET":
-    case "HEAD":
-    case "DELETE":
-      if (config2.schema?.body) {
-        console.warn(`Warning: ${method} requests typically don't have request bodies`);
-      }
-      break;
+  try {
+    const port = serverOptions.port;
+    const host = serverOptions.host;
+    await initializePlugins(serverInstance);
+    const http2Options = serverOptions.http2 || { enabled: true };
+    const isHttp2 = !!http2Options.enabled;
+    const certOptions = await prepareCertificates(http2Options);
+    if (serverOptions.http2 && certOptions.keyFile && certOptions.certFile) {
+      serverOptions.http2.keyFile = certOptions.keyFile;
+      serverOptions.http2.certFile = certOptions.certFile;
+    }
+    const server = createServerInstance(isHttp2, certOptions);
+    serverInstance.server = server;
+    serverInstance.port = port;
+    serverInstance.host = host;
+    const requestHandler = createRequestHandler(serverInstance);
+    server.on("request", requestHandler);
+    await listenOnPort(server, port, host, isHttp2);
+  } catch (error) {
+    console.error("Failed to start server:", error);
+    throw error;
   }
 }
-function validateSchema(method, schema) {
-  const { params, query, body, response } = schema;
-  if (params && (!params._def || typeof params.parse !== "function")) {
-    throw new Error(`Params schema for ${method} must be a valid Zod schema`);
+
+// 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 (query && (!query._def || typeof query.parse !== "function")) {
-    throw new Error(`Query schema for ${method} must be a valid Zod schema`);
+  if (!server) {
+    return;
   }
-  if (body && (!body._def || typeof body.parse !== "function")) {
-    throw new Error(`Body schema for ${method} must be a valid Zod schema`);
+  isShuttingDown = true;
+  const timeout = options.timeout || 5e3;
+  try {
+    if (options.onStopping) {
+      await options.onStopping();
+    }
+    events.emit("stopping");
+    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 timeout"));
+      }, timeout);
+    });
+    await Promise.race([closePromise, timeoutPromise]);
+    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;
   }
-  if (response && (!response._def || typeof response.parse !== "function")) {
-    throw new Error(`Response schema for ${method} must be a valid Zod schema`);
+}
+function registerSignalHandlers(stopFn) {
+  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/create.ts
-var import_node_async_hooks2 = require("async_hooks");
-var import_node_events = __toESM(require("events"), 1);
-
-// src/server/start.ts
-var fs3 = __toESM(require("fs"), 1);
-var http = __toESM(require("http"), 1);
-var http2 = __toESM(require("http2"), 1);
+// src/server/validation.ts
+var import_zod = require("zod");
+var middlewareSchema = import_zod.z.custom(
+  (data) => data !== null && typeof data === "object" && "execute" in data && typeof data.execute === "function",
+  {
+    message: "Expected middleware to have an execute function"
+  }
+);
+var pluginSchema = import_zod.z.custom(
+  (data) => data !== null && typeof data === "object" && "register" in data && typeof data.register === "function",
+  {
+    message: "Expected a valid plugin object with a register method"
+  }
+);
+var http2Schema = import_zod.z.object({
+  enabled: import_zod.z.boolean().optional().default(true),
+  keyFile: import_zod.z.string().optional(),
+  certFile: import_zod.z.string().optional()
+}).refine(
+  (data) => {
+    if (data.enabled && process.env.NODE_ENV === "production") {
+      return data.keyFile && data.certFile;
+    }
+    return true;
+  },
+  {
+    message: "When HTTP/2 is enabled (outside of development mode), both keyFile and certFile must be provided"
+  }
+);
+var serverOptionsSchema = import_zod.z.object({
+  port: import_zod.z.number().int().positive().optional().default(3e3),
+  host: import_zod.z.string().optional().default("localhost"),
+  routesDir: import_zod.z.string().optional().default("./routes"),
+  http2: http2Schema.optional().default({
+    enabled: true
+  }),
+  middleware: import_zod.z.array(middlewareSchema).optional().default([]),
+  plugins: import_zod.z.array(pluginSchema).optional().default([])
+});
+function validateServerOptions(options) {
+  try {
+    return serverOptionsSchema.parse(options);
+  } catch (error) {
+    if (error instanceof import_zod.z.ZodError) {
+      const formattedError = error.format();
+      throw new Error(`Invalid server options: ${JSON.stringify(formattedError, null, 2)}`);
+    }
+    throw new Error(`Invalid server options: ${String(error)}`);
+  }
+}
 
-// src/server/dev-certificate.ts
-var fs2 = __toESM(require("fs"), 1);
-var path4 = __toESM(require("path"), 1);
-var selfsigned = __toESM(require("selfsigned"), 1);
-async function generateDevCertificates() {
-  const certDir = path4.join(process.cwd(), ".blaizejs", "certs");
-  const keyPath = path4.join(certDir, "dev.key");
-  const certPath = path4.join(certDir, "dev.cert");
-  if (fs2.existsSync(keyPath) && fs2.existsSync(certPath)) {
-    return {
-      keyFile: keyPath,
-      certFile: certPath
-    };
+// src/plugins/lifecycle.ts
+function createPluginLifecycleManager(options = {}) {
+  const { continueOnError = true, debug = false, onError } = options;
+  function log(message, ...args) {
+    if (debug) {
+      console.log(`[PluginLifecycle] ${message}`, ...args);
+    }
   }
-  if (!fs2.existsSync(certDir)) {
-    fs2.mkdirSync(certDir, { recursive: true });
+  function handleError(plugin, phase, error) {
+    const errorMessage = `Plugin ${plugin.name} failed during ${phase}: ${error.message}`;
+    if (onError) {
+      onError(plugin, phase, error);
+    } else {
+      console.error(errorMessage, error);
+    }
+    if (!continueOnError) {
+      throw new Error(errorMessage);
+    }
   }
-  const attrs = [{ name: "commonName", value: "localhost" }];
-  const options = {
-    days: 365,
-    algorithm: "sha256",
-    keySize: 2048,
-    extensions: [
-      { name: "basicConstraints", cA: true },
-      {
-        name: "keyUsage",
-        keyCertSign: true,
-        digitalSignature: true,
-        nonRepudiation: true,
-        keyEncipherment: true,
-        dataEncipherment: true
-      },
-      {
-        name: "extKeyUsage",
-        serverAuth: true,
-        clientAuth: true
-      },
-      {
-        name: "subjectAltName",
-        altNames: [
-          { type: 2, value: "localhost" },
-          { type: 7, ip: "127.0.0.1" }
-        ]
+  return {
+    /**
+     * Initialize all plugins
+     */
+    async initializePlugins(server) {
+      log("Initializing plugins...");
+      for (const plugin of server.plugins) {
+        if (plugin.initialize) {
+          try {
+            log(`Initializing plugin: ${plugin.name}`);
+            await plugin.initialize(server);
+          } catch (error) {
+            handleError(plugin, "initialize", error);
+          }
+        }
+      }
+      log(`Initialized ${server.plugins.length} plugins`);
+    },
+    /**
+     * Terminate all plugins in reverse order
+     */
+    async terminatePlugins(server) {
+      log("Terminating plugins...");
+      const pluginsToTerminate = [...server.plugins].reverse();
+      for (const plugin of pluginsToTerminate) {
+        if (plugin.terminate) {
+          try {
+            log(`Terminating plugin: ${plugin.name}`);
+            await plugin.terminate(server);
+          } catch (error) {
+            handleError(plugin, "terminate", error);
+          }
+        }
+      }
+      log(`Terminated ${pluginsToTerminate.length} plugins`);
+    },
+    /**
+     * Notify plugins that the server has started
+     */
+    async onServerStart(server, httpServer) {
+      log("Notifying plugins of server start...");
+      for (const plugin of server.plugins) {
+        if (plugin.onServerStart) {
+          try {
+            log(`Notifying plugin of server start: ${plugin.name}`);
+            await plugin.onServerStart(httpServer);
+          } catch (error) {
+            handleError(plugin, "onServerStart", error);
+          }
+        }
+      }
+    },
+    /**
+     * Notify plugins that the server is stopping
+     */
+    async onServerStop(server, httpServer) {
+      log("Notifying plugins of server stop...");
+      const pluginsToNotify = [...server.plugins].reverse();
+      for (const plugin of pluginsToNotify) {
+        if (plugin.onServerStop) {
+          try {
+            log(`Notifying plugin of server stop: ${plugin.name}`);
+            await plugin.onServerStop(httpServer);
+          } catch (error) {
+            handleError(plugin, "onServerStop", error);
+          }
+        }
       }
-    ]
-  };
-  const pems = selfsigned.generate(attrs, options);
-  fs2.writeFileSync(keyPath, Buffer.from(pems.private, "utf-8"));
-  fs2.writeFileSync(certPath, Buffer.from(pems.cert, "utf-8"));
-  console.log(`
-\u{1F512} Generated self-signed certificates for development at ${certDir}
-`);
-  return {
-    keyFile: keyPath,
-    certFile: certPath
+    }
   };
 }
 
-// src/context/errors.ts
-var ResponseSentError = class extends Error {
-  constructor(message = "\u274C Response has already been sent") {
-    super(message);
-    this.name = "ResponseSentError";
+// src/plugins/errors.ts
+var PluginValidationError = class extends Error {
+  constructor(pluginName, message) {
+    super(`Plugin validation error${pluginName ? ` for "${pluginName}"` : ""}: ${message}`);
+    this.pluginName = pluginName;
+    this.name = "PluginValidationError";
   }
 };
-var ResponseSentHeaderError = class extends ResponseSentError {
-  constructor(message = "Cannot set header after response has been sent") {
-    super(message);
+
+// src/plugins/validation.ts
+var RESERVED_NAMES = /* @__PURE__ */ new Set([
+  "core",
+  "server",
+  "router",
+  "middleware",
+  "context",
+  "blaize",
+  "blaizejs"
+]);
+var VALID_NAME_PATTERN = /^[a-z]([a-z0-9-]*[a-z0-9])?$/;
+var VALID_VERSION_PATTERN = /^\d+\.\d+\.\d+(?:-[a-zA-Z0-9-.]+)?(?:\+[a-zA-Z0-9-.]+)?$/;
+function validatePlugin(plugin, options = {}) {
+  const { requireVersion = true, validateNameFormat = true, checkReservedNames = true } = options;
+  if (!plugin || typeof plugin !== "object") {
+    throw new PluginValidationError("", "Plugin must be an object");
   }
-};
-var ResponseSentContentError = class extends ResponseSentError {
-  constructor(message = "Cannot set content type after response has been sent") {
-    super(message);
+  const p = plugin;
+  if (!p.name || typeof p.name !== "string") {
+    throw new PluginValidationError("", "Plugin must have a name (string)");
   }
-};
-var ParseUrlError = class extends ResponseSentError {
-  constructor(message = "Invalide URL") {
-    super(message);
+  if (validateNameFormat && !VALID_NAME_PATTERN.test(p.name)) {
+    throw new PluginValidationError(
+      p.name,
+      "Plugin name must be lowercase letters, numbers, and hyphens only"
+    );
+  }
+  if (checkReservedNames && RESERVED_NAMES.has(p.name.toLowerCase())) {
+    throw new PluginValidationError(p.name, `Plugin name "${p.name}" is reserved`);
+  }
+  if (requireVersion) {
+    if (!p.version || typeof p.version !== "string") {
+      throw new PluginValidationError(p.name, "Plugin must have a version (string)");
+    }
+    if (!VALID_VERSION_PATTERN.test(p.version)) {
+      throw new PluginValidationError(
+        p.name,
+        'Plugin version must follow semantic versioning (e.g., "1.0.0")'
+      );
+    }
+  }
+  if (!p.register || typeof p.register !== "function") {
+    throw new PluginValidationError(p.name, "Plugin must have a register method (function)");
+  }
+  const lifecycleMethods = ["initialize", "terminate", "onServerStart", "onServerStop"];
+  for (const method of lifecycleMethods) {
+    if (p[method] && typeof p[method] !== "function") {
+      throw new PluginValidationError(p.name, `Plugin ${method} must be a function if provided`);
+    }
   }
-};
-
-// src/context/store.ts
-var import_node_async_hooks = require("async_hooks");
-var contextStorage = new import_node_async_hooks.AsyncLocalStorage();
-function runWithContext(context, callback) {
-  return contextStorage.run(context, callback);
 }
 
-// src/context/create.ts
-var CONTENT_TYPE_HEADER = "Content-Type";
-function parseRequestUrl(req) {
-  const originalUrl = req.url || "/";
-  const host = req.headers.host || "localhost";
-  const protocol = req.socket && req.socket.encrypted ? "https" : "http";
-  const fullUrl = `${protocol}://${host}${originalUrl.startsWith("/") ? "" : "/"}${originalUrl}`;
+// src/router/discovery/cache.ts
+var crypto = __toESM(require("crypto"), 1);
+var fs3 = __toESM(require("fs/promises"), 1);
+var import_node_module = require("module");
+var path3 = __toESM(require("path"), 1);
+
+// src/router/discovery/loader.ts
+async function dynamicImport(filePath) {
+  const cacheBuster = `?t=${Date.now()}`;
+  const importPath = filePath + cacheBuster;
   try {
-    const url = new URL(fullUrl);
-    const path5 = url.pathname;
-    const query = {};
-    url.searchParams.forEach((value, key) => {
-      if (query[key] !== void 0) {
-        if (Array.isArray(query[key])) {
-          query[key].push(value);
-        } else {
-          query[key] = [query[key], value];
-        }
-      } else {
-        query[key] = value;
-      }
-    });
-    return { path: path5, url, query };
+    const module2 = await import(importPath);
+    console.log(`\u2705 Successfully imported module`);
+    return module2;
   } catch (error) {
-    console.warn(`Invalid URL: ${fullUrl}`, error);
-    throw new ParseUrlError(`Invalid URL: ${fullUrl}`);
+    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);
   }
 }
-function isHttp2Request(req) {
-  return "stream" in req || "httpVersionMajor" in req && req.httpVersionMajor === 2;
-}
-function getProtocol(req) {
-  const encrypted = req.socket && req.socket.encrypted;
-  const forwardedProto = req.headers["x-forwarded-proto"];
-  if (forwardedProto) {
-    if (Array.isArray(forwardedProto)) {
-      return forwardedProto[0]?.split(",")[0]?.trim() || "http";
-    } else {
-      return forwardedProto.split(",")[0]?.trim() || "http";
+async function loadRouteModule(filePath, basePath) {
+  try {
+    const parsedRoute = parseRoutePath(filePath, basePath);
+    const module2 = await dynamicImport(filePath);
+    console.log("\u{1F4E6} Module exports:", Object.keys(module2));
+    const routes = [];
+    if (module2.default && typeof module2.default === "object") {
+      const route = {
+        ...module2.default,
+        path: parsedRoute.routePath
+      };
+      routes.push(route);
+    }
+    Object.entries(module2).forEach(([exportName, exportValue]) => {
+      if (exportName === "default" || !exportValue || typeof exportValue !== "object") {
+        return;
+      }
+      const potentialRoute = exportValue;
+      if (isValidRoute(potentialRoute)) {
+        const route = {
+          ...potentialRoute,
+          // Use the route's own path if it has one, otherwise derive from file
+          path: parsedRoute.routePath
+        };
+        routes.push(route);
+      }
+    });
+    if (routes.length === 0) {
+      console.warn(`Route file ${filePath} does not export any valid route definitions`);
+      return [];
     }
+    console.log(`\u2705 Successfully Loaded ${routes.length} route(s)`);
+    return routes;
+  } catch (error) {
+    console.error(`Failed to load route module ${filePath}:`, error);
+    return [];
   }
-  return encrypted ? "https" : "http";
 }
-async function createContext(req, res, options = {}) {
-  const { path: path5, url, query } = parseRequestUrl(req);
-  const method = req.method || "GET";
-  const isHttp2 = isHttp2Request(req);
-  const protocol = getProtocol(req);
-  const params = {};
-  const state = { ...options.initialState || {} };
-  const responseState = { sent: false };
-  const ctx = {
-    request: createRequestObject(req, {
-      path: path5,
-      url,
-      query,
-      params,
-      method,
-      isHttp2,
-      protocol
-    }),
-    response: {},
-    state
-  };
-  ctx.response = createResponseObject(res, responseState, ctx);
-  if (options.parseBody) {
-    await parseBodyIfNeeded(req, ctx);
+function isValidRoute(obj) {
+  if (!obj || typeof obj !== "object") {
+    return false;
   }
-  return ctx;
-}
-function createRequestObject(req, info) {
-  return {
-    raw: req,
-    ...info,
-    header: createRequestHeaderGetter(req),
-    headers: createRequestHeadersGetter(req),
-    body: void 0
-  };
-}
-function createRequestHeaderGetter(req) {
-  return (name) => {
-    const value = req.headers[name.toLowerCase()];
-    if (Array.isArray(value)) {
-      return value.join(", ");
-    }
-    return value || void 0;
-  };
+  const httpMethods = ["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"];
+  const hasHttpMethod = httpMethods.some(
+    (method) => obj[method] && typeof obj[method] === "object" && obj[method].handler
+  );
+  return hasHttpMethod;
 }
-function createRequestHeadersGetter(req) {
-  const headerGetter = createRequestHeaderGetter(req);
-  return (names) => {
-    if (names && Array.isArray(names) && names.length > 0) {
-      return names.reduce((acc, name) => {
-        acc[name] = headerGetter(name);
-        return acc;
-      }, {});
-    } else {
-      return Object.entries(req.headers).reduce(
-        (acc, [key, value]) => {
-          acc[key] = Array.isArray(value) ? value.join(", ") : value || void 0;
-          return acc;
-        },
-        {}
-      );
-    }
-  };
+
+// src/router/discovery/cache.ts
+var import_meta = {};
+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 createResponseObject(res, responseState, ctx) {
-  return {
-    raw: res,
-    get sent() {
-      return responseState.sent;
-    },
-    status: createStatusSetter(res, responseState, ctx),
-    header: createHeaderSetter(res, responseState, ctx),
-    headers: createHeadersSetter(res, responseState, ctx),
-    type: createContentTypeSetter(res, responseState, ctx),
-    json: createJsonResponder(res, responseState),
-    text: createTextResponder(res, responseState),
-    html: createHtmlResponder(res, responseState),
-    redirect: createRedirectResponder(res, responseState),
-    stream: createStreamResponder(res, responseState)
-  };
+function hasRouteContentChanged(filePath, newRoutes) {
+  const cachedEntry = fileRouteCache.get(filePath);
+  if (!cachedEntry) {
+    return true;
+  }
+  const newHash = hashRoutes(newRoutes);
+  return cachedEntry.hash !== newHash;
 }
-function createStatusSetter(res, responseState, ctx) {
-  return function statusSetter(code) {
-    if (responseState.sent) {
-      throw new ResponseSentError();
-    }
-    res.statusCode = code;
-    return ctx.response;
-  };
+function clearFileCache(filePath) {
+  if (filePath) {
+    fileRouteCache.delete(filePath);
+  } else {
+    fileRouteCache.clear();
+  }
 }
-function createHeaderSetter(res, responseState, ctx) {
-  return function headerSetter(name, value) {
-    if (responseState.sent) {
-      throw new ResponseSentHeaderError();
+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 = (0, import_node_module.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`);
+      }
     }
-    res.setHeader(name, value);
-    return ctx.response;
-  };
+  } catch (error) {
+    console.log(`\u26A0\uFE0F Error during module cache invalidation for ${filePath}:`, error);
+  }
 }
-function createHeadersSetter(res, responseState, ctx) {
-  return function headersSetter(headers) {
-    if (responseState.sent) {
-      throw new ResponseSentHeaderError();
+
+// src/router/discovery/parallel.ts
+var os = __toESM(require("os"), 1);
+
+// src/router/discovery/finder.ts
+var fs4 = __toESM(require("fs/promises"), 1);
+var path4 = __toESM(require("path"), 1);
+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}`);
     }
-    for (const [name, value] of Object.entries(headers)) {
-      res.setHeader(name, value);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new Error(`Route directory not found: ${absoluteDir}`);
     }
-    return ctx.response;
-  };
-}
-function createContentTypeSetter(res, responseState, ctx) {
-  return function typeSetter(type) {
-    if (responseState.sent) {
-      throw new ResponseSentContentError();
+    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);
+      }
     }
-    res.setHeader(CONTENT_TYPE_HEADER, type);
-    return ctx.response;
-  };
+  }
+  await scanDirectory(absoluteDir);
+  return routeFiles;
 }
-function createJsonResponder(res, responseState) {
-  return function jsonResponder(body, status) {
-    if (responseState.sent) {
-      throw new ResponseSentError();
-    }
-    if (status !== void 0) {
-      res.statusCode = status;
+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;
     }
-    res.setHeader(CONTENT_TYPE_HEADER, "application/json");
-    res.end(JSON.stringify(body));
-    responseState.sent = true;
   };
 }
-function createTextResponder(res, responseState) {
-  return function textResponder(body, status) {
-    if (responseState.sent) {
-      throw new ResponseSentError();
+
+// src/router/discovery/watchers.ts
+var path5 = __toESM(require("path"), 1);
+var import_chokidar = require("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 {
+      const files = await findRouteFiles(routesDir, {
+        ignore: options.ignore
+      });
+      for (const filePath of files) {
+        await loadAndNotify(filePath);
+      }
+    } catch (error) {
+      handleError(error);
     }
-    if (status !== void 0) {
-      res.statusCode = status;
+  }
+  async function loadAndNotify(filePath) {
+    try {
+      const existingRoutes = routesByPath.get(filePath);
+      const newRoutes = await processChangedFile(filePath, routesDir, false);
+      if (!newRoutes || newRoutes.length === 0) {
+        return;
+      }
+      if (existingRoutes && !hasRouteContentChanged(filePath, newRoutes)) {
+        return;
+      }
+      await processChangedFile(filePath, routesDir, true);
+      const normalizedPath = path5.normalize(filePath);
+      if (existingRoutes) {
+        routesByPath.set(filePath, newRoutes);
+        if (options.onRouteChanged) {
+          options.onRouteChanged(normalizedPath, newRoutes);
+        }
+      } else {
+        routesByPath.set(filePath, newRoutes);
+        if (options.onRouteAdded) {
+          options.onRouteAdded(normalizedPath, newRoutes);
+        }
+      }
+    } catch (error) {
+      console.log(`\u26A0\uFE0F Error processing file ${filePath}:`, error);
+      handleError(error);
     }
-    res.setHeader(CONTENT_TYPE_HEADER, "text/plain");
-    res.end(body);
-    responseState.sent = true;
-  };
-}
-function createHtmlResponder(res, responseState) {
-  return function htmlResponder(body, status) {
-    if (responseState.sent) {
-      throw new ResponseSentError();
+  }
+  function handleRemoved(filePath) {
+    const normalizedPath = path5.normalize(filePath);
+    const routes = routesByPath.get(normalizedPath);
+    if (routes && routes.length > 0 && options.onRouteRemoved) {
+      options.onRouteRemoved(normalizedPath, routes);
     }
-    if (status !== void 0) {
-      res.statusCode = status;
+    routesByPath.delete(normalizedPath);
+  }
+  function handleError(error) {
+    if (options.onError && error instanceof Error) {
+      options.onError(error);
+    } else {
+      console.error("\u26A0\uFE0F Route watcher error:", error);
     }
-    res.setHeader(CONTENT_TYPE_HEADER, "text/html");
-    res.end(body);
-    responseState.sent = true;
+  }
+  const watcher = (0, import_chokidar.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: [
+      /(^|[/\\])\../,
+      /node_modules/,
+      /\.git/,
+      /\.DS_Store/,
+      /Thumbs\.db/,
+      /\.(test|spec)\.(ts|js)$/,
+      /\.d\.ts$/,
+      /\.map$/,
+      /~$/,
+      ...options.ignore || []
+    ]
+  });
+  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: () => {
+      debouncedCallbacks.forEach((timeout) => clearTimeout(timeout));
+      debouncedCallbacks.clear();
+      return watcher.close();
+    },
+    getRoutes: () => {
+      const allRoutes = [];
+      for (const routes of routesByPath.values()) {
+        allRoutes.push(...routes);
+      }
+      return allRoutes;
+    },
+    getRoutesByFile: () => new Map(routesByPath)
   };
 }
-function createRedirectResponder(res, responseState) {
-  return function redirectResponder(url, status = 302) {
-    if (responseState.sent) {
-      throw new ResponseSentError();
-    }
-    res.statusCode = status;
-    res.setHeader("Location", url);
-    res.end();
-    responseState.sent = true;
+
+// 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)
   };
-}
-function createStreamResponder(res, responseState) {
-  return function streamResponder(readable, options = {}) {
-    if (responseState.sent) {
-      throw new ResponseSentError();
+  if (options.detailed) {
+    if (error instanceof Error) {
+      response.stack = error.stack;
     }
-    if (options.status !== void 0) {
-      res.statusCode = options.status;
+    if (error && typeof error === "object" && "details" in error && error.details) {
+      response.details = error.details;
     }
-    if (options.contentType) {
-      res.setHeader(CONTENT_TYPE_HEADER, options.contentType);
+  }
+  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 (options.headers) {
-      for (const [name, value] of Object.entries(options.headers)) {
-        res.setHeader(name, value);
-      }
+    if ("statusCode" in error && typeof error.statusCode === "number") {
+      return error.statusCode;
     }
-    readable.pipe(res);
-    readable.on("end", () => {
-      responseState.sent = true;
-    });
-    readable.on("error", (err) => {
-      console.error("Stream error:", err);
-      if (!responseState.sent) {
-        res.statusCode = 500;
-        res.end("Stream error");
-        responseState.sent = true;
-      }
-    });
-  };
+    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;
+  }
 }
-async function parseBodyIfNeeded(req, ctx) {
-  if (shouldSkipParsing(req.method)) {
-    return;
+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;
+    }
   }
-  const contentType = req.headers["content-type"] || "";
-  const contentLength = parseInt(req.headers["content-length"] || "0", 10);
-  if (contentLength === 0 || contentLength > 1048576) {
-    return;
+  return "Error";
+}
+function getErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
   }
-  try {
-    await parseBodyByContentType(req, ctx, contentType);
-  } catch (error) {
-    setBodyError(ctx, "body_read_error", "Error reading request body", error);
+  if (error && typeof error === "object") {
+    if ("message" in error && typeof error.message === "string") {
+      return error.message;
+    }
   }
+  return String(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);
+
+// src/router/validation/body.ts
+var import_zod2 = require("zod");
+function validateBody(body, schema) {
+  if (schema instanceof import_zod2.z.ZodObject) {
+    return schema.strict().parse(body);
   }
+  return schema.parse(body);
 }
-async function parseJsonBody(req, ctx) {
-  const body = await readRequestBody(req);
-  if (!body) {
-    console.warn("Empty body, skipping JSON parsing");
-    return;
-  }
-  if (body.trim() === "null") {
-    console.warn('Body is the string "null"');
-    ctx.request.body = null;
-    return;
+
+// src/router/validation/params.ts
+var import_zod3 = require("zod");
+function validateParams(params, schema) {
+  if (schema instanceof import_zod3.z.ZodObject) {
+    return schema.strict().parse(params);
   }
-  try {
-    const json = JSON.parse(body);
-    ctx.request.body = json;
-  } catch (error) {
-    ctx.request.body = null;
-    setBodyError(ctx, "json_parse_error", "Invalid JSON in request body", error);
+  return schema.parse(params);
+}
+
+// src/router/validation/query.ts
+var import_zod4 = require("zod");
+function validateQuery(query, schema) {
+  if (schema instanceof import_zod4.z.ZodObject) {
+    return schema.strict().parse(query);
   }
+  return schema.parse(query);
 }
-async function parseFormUrlEncodedBody(req, ctx) {
-  const body = await readRequestBody(req);
-  if (!body) return;
-  try {
-    ctx.request.body = parseUrlEncodedData(body);
-  } catch (error) {
-    ctx.request.body = null;
-    setBodyError(ctx, "form_parse_error", "Invalid form data in request body", error);
+
+// src/router/validation/response.ts
+var import_zod5 = require("zod");
+function validateResponse(response, schema) {
+  if (schema instanceof import_zod5.z.ZodObject) {
+    return schema.strict().parse(response);
   }
+  return schema.parse(response);
 }
-function parseUrlEncodedData(body) {
-  const params = new URLSearchParams(body);
-  const formData = {};
-  params.forEach((value, key) => {
-    if (formData[key] !== void 0) {
-      if (Array.isArray(formData[key])) {
-        formData[key].push(value);
-      } else {
-        formData[key] = [formData[key], value];
+
+// 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);
       }
-    } else {
-      formData[key] = value;
     }
-  });
-  return formData;
-}
-async function parseTextBody(req, ctx) {
-  const body = await readRequestBody(req);
-  if (body) {
-    ctx.request.body = body;
-  }
+    if (schema.query && ctx.request.query) {
+      try {
+        ctx.request.query = validateQuery(ctx.request.query, schema.query);
+      } catch (error) {
+        errors.query = formatValidationError(error);
+      }
+    }
+    if (schema.body) {
+      try {
+        ctx.request.body = validateBody(ctx.request.body, schema.body);
+      } catch (error) {
+        errors.body = formatValidationError(error);
+      }
+    }
+    if (Object.keys(errors).length > 0) {
+      ctx.response.status(400).json({
+        error: "Validation Error",
+        details: errors
+      });
+      return;
+    }
+    await next();
+  };
+  return {
+    name: "RequestValidator",
+    execute: middlewareFn,
+    debug
+  };
 }
-function setBodyError(ctx, type, message, error) {
-  ctx.state._bodyError = { type, message, error };
+function createResponseValidator(responseSchema, debug = false) {
+  const middlewareFn = async (ctx, next) => {
+    const originalJson = ctx.response.json;
+    ctx.response.json = (body, status) => {
+      try {
+        const validatedBody = validateResponse(body, responseSchema);
+        ctx.response.json = originalJson;
+        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"
+        });
+        return ctx.response;
+      }
+    };
+    await next();
+  };
+  return {
+    name: "ResponseValidator",
+    execute: middlewareFn,
+    debug
+  };
 }
-async function readRequestBody(req) {
-  return new Promise((resolve2, 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"));
-    });
-    req.on("error", (err) => {
-      reject(err);
-    });
-  });
+function formatValidationError(error) {
+  if (error && typeof error === "object" && "format" in error && typeof error.format === "function") {
+    return error.format();
+  }
+  return error instanceof Error ? error.message : String(error);
 }
 
-// src/server/request-handler.ts
-function createRequestHandler(serverInstance) {
-  return async (req, res) => {
-    try {
-      const context = await createContext(req, res, {
-        parseBody: true
-        // Enable automatic body parsing
-      });
-      const handler = compose(serverInstance.middleware);
-      await runWithContext(context, async () => {
-        try {
-          await handler(context, async () => {
-            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}`
-                });
-              }
-            }
-          });
-        } 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);
-      res.writeHead(500, { "Content-Type": "application/json" });
-      res.end(
-        JSON.stringify({
-          error: "Internal Server Error",
-          message: "Failed to process request"
-        })
-      );
+// src/router/handlers/executor.ts
+async function executeHandler(ctx, routeOptions, params) {
+  const middleware = [...routeOptions.middleware || []];
+  if (routeOptions.schema) {
+    if (routeOptions.schema.params || routeOptions.schema.query || routeOptions.schema.body) {
+      middleware.unshift(createRequestValidator(routeOptions.schema));
+    }
+    if (routeOptions.schema.response) {
+      middleware.push(createResponseValidator(routeOptions.schema.response));
+    }
+  }
+  const handler = compose([...middleware]);
+  await handler(ctx, async () => {
+    const result = await routeOptions.handler(ctx, params);
+    if (!ctx.response.sent && result !== void 0) {
+      ctx.response.json(result);
     }
-  };
+  });
 }
 
-// src/server/start.ts
-async function prepareCertificates(http2Options) {
-  if (!http2Options.enabled) {
+// src/router/matching/params.ts
+function extractParams(path6, pattern, paramNames) {
+  const match = pattern.exec(path6);
+  if (!match) {
     return {};
   }
-  const { keyFile, certFile } = http2Options;
-  const isDevMode = process.env.NODE_ENV === "development";
-  const certificatesMissing = !keyFile || !certFile;
-  if (certificatesMissing && isDevMode) {
-    const devCerts = await generateDevCertificates();
-    return devCerts;
-  }
-  if (certificatesMissing) {
-    throw new Error(
-      "HTTP/2 requires SSL certificates. Provide keyFile and certFile in http2 options. In development, set NODE_ENV=development to generate them automatically."
-    );
+  const params = {};
+  for (let i = 0; i < paramNames.length; i++) {
+    params[paramNames[i]] = match[i + 1] || "";
   }
-  return { keyFile, certFile };
+  return params;
 }
-function createServerInstance(isHttp2, certOptions) {
-  if (!isHttp2) {
-    return http.createServer();
+function compilePathPattern(path6) {
+  const paramNames = [];
+  if (path6 === "/") {
+    return {
+      pattern: /^\/$/,
+      paramNames: []
+    };
   }
-  const http2ServerOptions = {
-    allowHTTP1: true
-    // Allow fallback to HTTP/1.1
+  let patternString = path6.replace(/([.+*?^$(){}|\\])/g, "\\$1");
+  patternString = patternString.replace(/\/:([^/]+)/g, (_, paramName) => {
+    paramNames.push(paramName);
+    return "/([^/]+)";
+  }).replace(/\/\[([^\]]+)\]/g, (_, paramName) => {
+    paramNames.push(paramName);
+    return "/([^/]+)";
+  });
+  patternString = `${patternString}(?:/)?`;
+  const pattern = new RegExp(`^${patternString}$`);
+  return {
+    pattern,
+    paramNames
   };
-  try {
-    if (certOptions.keyFile) {
-      http2ServerOptions.key = fs3.readFileSync(certOptions.keyFile);
-    }
-    if (certOptions.certFile) {
-      http2ServerOptions.cert = fs3.readFileSync(certOptions.certFile);
-    }
-  } catch (err) {
-    throw new Error(
-      `Failed to read certificate files: ${err instanceof Error ? err.message : String(err)}`
-    );
-  }
-  return http2.createSecureServer(http2ServerOptions);
 }
-function listenOnPort(server, port, host, isHttp2) {
-  return new Promise((resolve2, reject) => {
-    server.listen(port, host, () => {
-      const protocol = isHttp2 ? "https" : "http";
-      const url = `${protocol}://${host}:${port}`;
-      console.log(`
-\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}
 
-    \u26A1 BlaizeJS DEVELOPMENT SERVER HOT AND READY \u26A1
-    
-    \u{1F680} Server: ${url}
-    \u{1F525} Hot Reload: Enabled
-    \u{1F6E0}\uFE0F  Mode: Development
-    
-    Time to build something amazing! \u{1F680}
+// src/router/matching/matcher.ts
+function createMatcher() {
+  const routes = [];
+  return {
+    /**
+     * Add a route to the matcher
+     */
+    add(path6, method, routeOptions) {
+      const { pattern, paramNames } = compilePathPattern(path6);
+      const newRoute = {
+        path: path6,
+        method,
+        pattern,
+        paramNames,
+        routeOptions
+      };
+      const insertIndex = routes.findIndex((route) => paramNames.length < route.paramNames.length);
+      if (insertIndex === -1) {
+        routes.push(newRoute);
+      } else {
+        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(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(path6, route.pattern, route.paramNames);
+          return {
+            route: route.routeOptions,
+            params
+          };
+        }
+      }
+      const matchingPath = routes.find(
+        (route) => route.method !== method && route.pattern.test(path6)
+      );
+      if (matchingPath) {
+        return {
+          route: null,
+          params: {},
+          methodNotAllowed: true,
+          allowedMethods: routes.filter((route) => route.pattern.test(path6)).map((route) => route.method)
+        };
+      }
+      return null;
+    },
+    /**
+     * Get all registered routes
+     */
+    getRoutes() {
+      return routes.map((route) => ({
+        path: route.path,
+        method: route.method
+      }));
+    },
+    /**
+     * Find routes matching a specific path
+     */
+    findRoutes(path6) {
+      return routes.filter((route) => route.pattern.test(path6)).map((route) => ({
+        path: route.path,
+        method: route.method,
+        params: extractParams(path6, route.pattern, route.paramNames)
+      }));
+    }
+  };
+}
 
-\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();
-    });
-    server.on("error", (err) => {
-      console.error("Server error:", err);
-      reject(err);
-    });
+// 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 };
 }
-async function initializePlugins(serverInstance) {
-  for (const plugin of serverInstance.plugins) {
-    if (typeof plugin.initialize === "function") {
-      await plugin.initialize(serverInstance);
-    }
-  }
+function getAllRoutesFromRegistry(registry) {
+  return Array.from(registry.routesByPath.values());
 }
-async function startServer(serverInstance, serverOptions) {
-  if (serverInstance.server) {
-    return;
-  }
-  try {
-    const port = serverOptions.port;
-    const host = serverOptions.host;
-    await initializePlugins(serverInstance);
-    const http2Options = serverOptions.http2 || { enabled: true };
-    const isHttp2 = !!http2Options.enabled;
-    const certOptions = await prepareCertificates(http2Options);
-    if (serverOptions.http2 && certOptions.keyFile && certOptions.certFile) {
-      serverOptions.http2.keyFile = certOptions.keyFile;
-      serverOptions.http2.certFile = certOptions.certFile;
-    }
-    const server = createServerInstance(isHttp2, certOptions);
-    serverInstance.server = server;
-    serverInstance.port = port;
-    serverInstance.host = host;
-    const requestHandler = createRequestHandler(serverInstance);
-    server.on("request", requestHandler);
-    await listenOnPort(server, port, host, isHttp2);
-  } catch (error) {
-    console.error("Failed to start server:", error);
-    throw error;
-  }
+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/server/stop.ts
-async function stopServer(serverInstance, options = {}) {
-  const server = serverInstance.server;
-  const events = serverInstance.events;
-  if (!server) {
-    return;
-  }
-  const timeout = options.timeout || 3e4;
-  try {
-    if (options.onStopping) {
-      await options.onStopping();
-    }
-    events.emit("stopping");
-    await serverInstance.pluginManager.onServerStop(serverInstance, server);
-    const timeoutPromise = new Promise((_, reject) => {
-      setTimeout(() => {
-        reject(new Error("Server shutdown timed out waiting for requests to complete"));
-      }, 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);
-    if (options.onStopped) {
-      await options.onStopped();
-    }
-    events.emit("stopped");
-    serverInstance.server = null;
-  } catch (error) {
-    events.emit("error", error);
-    throw error;
+// 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 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);
-    }
-  };
+function updateRouteInMatcher(route, matcher) {
+  removeRouteFromMatcher(route.path, matcher);
+  addRouteToMatcher(route, matcher);
 }
 
-// src/server/validation.ts
-var import_zod5 = require("zod");
-var middlewareSchema = import_zod5.z.custom(
-  (data) => data !== null && typeof data === "object" && "execute" in data && typeof data.execute === "function",
-  {
-    message: "Expected middleware to have an execute function"
-  }
-);
-var pluginSchema = import_zod5.z.custom(
-  (data) => data !== null && typeof data === "object" && "register" in data && typeof data.register === "function",
-  {
-    message: "Expected a valid plugin object with a register method"
+// src/router/router.ts
+var DEFAULT_ROUTER_OPTIONS = {
+  routesDir: "./routes",
+  basePath: "/",
+  watchMode: process.env.NODE_ENV === "development"
+};
+function createRouter(options) {
+  const routerOptions = {
+    ...DEFAULT_ROUTER_OPTIONS,
+    ...options
+  };
+  if (options.basePath && !options.basePath.startsWith("/")) {
+    console.warn("Base path does nothing");
   }
-);
-var http2Schema = import_zod5.z.object({
-  enabled: import_zod5.z.boolean().optional().default(true),
-  keyFile: import_zod5.z.string().optional(),
-  certFile: import_zod5.z.string().optional()
-}).refine(
-  (data) => {
-    if (data.enabled && process.env.NODE_ENV === "production") {
-      return data.keyFile && data.certFile;
+  const registry = createRouteRegistry();
+  const matcher = createMatcher();
+  let initialized = false;
+  let initializationPromise = null;
+  let _watchers = null;
+  const routeDirectories = /* @__PURE__ */ new Set([routerOptions.routesDir]);
+  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;
     }
-    return true;
-  },
-  {
-    message: "When HTTP/2 is enabled (outside of development mode), both keyFile and certFile must be provided"
   }
-);
-var serverOptionsSchema = import_zod5.z.object({
-  port: import_zod5.z.number().int().positive().optional().default(3e3),
-  host: import_zod5.z.string().optional().default("localhost"),
-  routesDir: import_zod5.z.string().optional().default("./routes"),
-  http2: http2Schema.optional().default({
-    enabled: true
-  }),
-  middleware: import_zod5.z.array(middlewareSchema).optional().default([]),
-  plugins: import_zod5.z.array(pluginSchema).optional().default([])
-});
-function validateServerOptions(options) {
-  try {
-    return serverOptionsSchema.parse(options);
-  } catch (error) {
-    if (error instanceof import_zod5.z.ZodError) {
-      const formattedError = error.format();
-      throw new Error(`Invalid server options: ${JSON.stringify(formattedError, null, 2)}`);
+  async function loadRoutesFromDirectory(directory, source, prefix) {
+    try {
+      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}` : ""} (${changes.added.length} added, ${changes.changed.length} changed, ${changes.removed.length} removed)`
+      );
+    } catch (error) {
+      console.error(`\u26A0\uFE0F Failed to load routes from ${source}:`, error);
+      throw error;
     }
-    throw new Error(`Invalid server options: ${String(error)}`);
   }
-}
-
-// src/plugins/lifecycle.ts
-function createPluginLifecycleManager(options = {}) {
-  const { continueOnError = true, debug = false, onError } = options;
-  function log(message, ...args) {
-    if (debug) {
-      console.log(`[PluginLifecycle] ${message}`, ...args);
+  async function initialize() {
+    if (initialized || initializationPromise) {
+      return initializationPromise;
     }
+    initializationPromise = (async () => {
+      try {
+        await Promise.all(
+          Array.from(routeDirectories).map(
+            (directory) => loadRoutesFromDirectory(directory, directory)
+          )
+        );
+        if (routerOptions.watchMode) {
+          setupOptimizedWatching();
+        }
+        initialized = true;
+      } catch (error) {
+        console.error("\u26A0\uFE0F Failed to initialize router:", error);
+        throw error;
+      }
+    })();
+    return initializationPromise;
   }
-  function handleError(plugin, phase, error) {
-    const errorMessage = `Plugin ${plugin.name} failed during ${phase}: ${error.message}`;
-    if (onError) {
-      onError(plugin, phase, error);
-    } else {
-      console.error(errorMessage, error);
+  function setupOptimizedWatching() {
+    if (!_watchers) {
+      _watchers = /* @__PURE__ */ new Map();
     }
-    if (!continueOnError) {
-      throw new Error(errorMessage);
+    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);
+          }
+        });
+        _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) => {
+        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(`\u26A0\uFE0F Route watcher error for ${directory}:`, error);
+      }
+    });
+    _watchers.set(directory, watcher);
+    return watcher;
   }
+  initialize().catch((error) => {
+    console.error("\u26A0\uFE0F Failed to initialize router on creation:", error);
+  });
   return {
     /**
-     * Initialize all plugins
+     * Handle an incoming request
      */
-    async initializePlugins(server) {
-      log("Initializing plugins...");
-      for (const plugin of server.plugins) {
-        if (plugin.initialize) {
-          try {
-            log(`Initializing plugin: ${plugin.name}`);
-            await plugin.initialize(server);
-          } catch (error) {
-            handleError(plugin, "initialize", error);
-          }
+    async handleRequest(ctx) {
+      if (!initialized) {
+        console.log("\u{1F504} Router not initialized, initializing...");
+        await initialize();
+      }
+      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: "\u274C Method Not Allowed",
+          allowed: match.allowedMethods
+        });
+        if (match.allowedMethods && match.allowedMethods.length > 0) {
+          ctx.response.header("Allow", match.allowedMethods.join(", "));
         }
+        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
+        });
       }
-      log(`Initialized ${server.plugins.length} plugins`);
     },
     /**
-     * Terminate all plugins in reverse order
+     * Get all registered routes (using optimized registry)
      */
-    async terminatePlugins(server) {
-      log("Terminating plugins...");
-      const pluginsToTerminate = [...server.plugins].reverse();
-      for (const plugin of pluginsToTerminate) {
-        if (plugin.terminate) {
-          try {
-            log(`Terminating plugin: ${plugin.name}`);
-            await plugin.terminate(server);
-          } catch (error) {
-            handleError(plugin, "terminate", error);
-          }
-        }
-      }
-      log(`Terminated ${pluginsToTerminate.length} plugins`);
+    getRoutes() {
+      return getAllRoutesFromRegistry(registry);
     },
     /**
-     * Notify plugins that the server has started
+     * Add a route programmatically
      */
-    async onServerStart(server, httpServer) {
-      log("Notifying plugins of server start...");
-      for (const plugin of server.plugins) {
-        if (plugin.onServerStart) {
-          try {
-            log(`Notifying plugin of server start: ${plugin.name}`);
-            await plugin.onServerStart(httpServer);
-          } catch (error) {
-            handleError(plugin, "onServerStart", error);
-          }
+    addRoute(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) with optimized loading
+     */
+    async addRouteDirectory(directory, options2 = {}) {
+      if (routeDirectories.has(directory)) {
+        console.warn(`Route directory ${directory} already registered`);
+        return;
+      }
+      routeDirectories.add(directory);
+      if (initialized) {
+        await loadRoutesFromDirectory(directory, directory, options2.prefix);
+        if (routerOptions.watchMode) {
+          setupWatcherForNewDirectory(directory, options2.prefix);
         }
       }
     },
     /**
-     * Notify plugins that the server is stopping
+     * Get route conflicts (using registry)
      */
-    async onServerStop(server, httpServer) {
-      log("Notifying plugins of server stop...");
-      const pluginsToNotify = [...server.plugins].reverse();
-      for (const plugin of pluginsToNotify) {
-        if (plugin.onServerStop) {
-          try {
-            log(`Notifying plugin of server stop: ${plugin.name}`);
-            await plugin.onServerStop(httpServer);
-          } catch (error) {
-            handleError(plugin, "onServerStop", error);
-          }
+    getRouteConflicts() {
+      const conflicts = [];
+      return conflicts;
+    },
+    /**
+     * Close watchers and cleanup (useful for testing)
+     */
+    async close() {
+      if (_watchers) {
+        for (const watcher of _watchers.values()) {
+          await watcher.close();
         }
+        _watchers.clear();
       }
     }
   };
 }
 
-// src/plugins/errors.ts
-var PluginValidationError = class extends Error {
-  constructor(pluginName, message) {
-    super(`Plugin validation error${pluginName ? ` for "${pluginName}"` : ""}: ${message}`);
-    this.pluginName = pluginName;
-    this.name = "PluginValidationError";
-  }
-};
-
-// src/plugins/validation.ts
-var RESERVED_NAMES = /* @__PURE__ */ new Set([
-  "core",
-  "server",
-  "router",
-  "middleware",
-  "context",
-  "blaize",
-  "blaizejs"
-]);
-var VALID_NAME_PATTERN = /^[a-z]([a-z0-9-]*[a-z0-9])?$/;
-var VALID_VERSION_PATTERN = /^\d+\.\d+\.\d+(?:-[a-zA-Z0-9-.]+)?(?:\+[a-zA-Z0-9-.]+)?$/;
-function validatePlugin(plugin, options = {}) {
-  const { requireVersion = true, validateNameFormat = true, checkReservedNames = true } = options;
-  if (!plugin || typeof plugin !== "object") {
-    throw new PluginValidationError("", "Plugin must be an object");
-  }
-  const p = plugin;
-  if (!p.name || typeof p.name !== "string") {
-    throw new PluginValidationError("", "Plugin must have a name (string)");
-  }
-  if (validateNameFormat && !VALID_NAME_PATTERN.test(p.name)) {
-    throw new PluginValidationError(
-      p.name,
-      "Plugin name must be lowercase letters, numbers, and hyphens only"
-    );
-  }
-  if (checkReservedNames && RESERVED_NAMES.has(p.name.toLowerCase())) {
-    throw new PluginValidationError(p.name, `Plugin name "${p.name}" is reserved`);
-  }
-  if (requireVersion) {
-    if (!p.version || typeof p.version !== "string") {
-      throw new PluginValidationError(p.name, "Plugin must have a version (string)");
-    }
-    if (!VALID_VERSION_PATTERN.test(p.version)) {
-      throw new PluginValidationError(
-        p.name,
-        'Plugin version must follow semantic versioning (e.g., "1.0.0")'
-      );
-    }
-  }
-  if (!p.register || typeof p.register !== "function") {
-    throw new PluginValidationError(p.name, "Plugin must have a register method (function)");
-  }
-  const lifecycleMethods = ["initialize", "terminate", "onServerStart", "onServerStop"];
-  for (const method of lifecycleMethods) {
-    if (p[method] && typeof p[method] !== "function") {
-      throw new PluginValidationError(p.name, `Plugin ${method} must be a function if provided`);
-    }
-  }
-}
-
 // src/server/create.ts
 var DEFAULT_OPTIONS = {
   port: 3e3,